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)])
314 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
317 # ---------------------
318 # Warnings and checking
319 # ---------------------
321 # Check $CC warning features (if it's GCC).
322 # We want to use -pedantic, but we don't want warnings about
326 # * C++11 narrowing conversions in { }
327 # So, we only use -pedantic if we can disable those warnings.
329 # In stage 1, disable -Wformat warnings from old GCCs about new % codes
330 AC_ARG_ENABLE(build-format-warnings,
331 AS_HELP_STRING([--disable-build-format-warnings],[don't use -Wformat while building GCC]),
332 [],[enable_build_format_warnings=yes])
333 AS_IF([test $enable_build_format_warnings = no],
334 [wf_opt=-Wno-format],[wf_opt=])
335 ACX_PROG_CC_WARNING_OPTS(
336 m4_quote(m4_do([-W -Wall -Wno-narrowing -Wwrite-strings -Wcast-qual $wf_opt])), [loose_warn])
337 ACX_PROG_CC_WARNING_OPTS(
338 m4_quote(m4_do([-Wstrict-prototypes -Wmissing-prototypes])),
340 ACX_PROG_CC_WARNING_OPTS(
341 m4_quote(m4_do([-Wmissing-format-attribute])), [strict_warn])
342 ACX_PROG_CC_WARNING_OPTS(
343 m4_quote(m4_do([-Woverloaded-virtual])), [strict_warn])
344 ACX_PROG_CC_WARNING_OPTS(
345 m4_quote(m4_do([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
346 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
347 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
348 [-Wno-overlength-strings])), [strict_warn])
349 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
351 # The above macros do nothing if the compiler is not GCC. However, the
352 # Makefile has more goo to add other flags, so these variables are used
353 # to enable warnings only for GCC.
356 if test "x$GCC" = "xyes"; then
357 warn_cflags='$(GCC_WARN_CFLAGS)'
358 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
360 AC_SUBST(warn_cflags)
361 AC_SUBST(warn_cxxflags)
363 # Disable exceptions and RTTI if building with g++
364 ACX_PROG_CC_WARNING_OPTS(
365 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
368 # Enable expensive internal checks
370 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
374 AC_ARG_ENABLE(checking,
375 [AS_HELP_STRING([[--enable-checking[=LIST]]],
376 [enable expensive run-time checks. With LIST,
377 enable only specific categories of checks.
378 Categories are: yes,no,all,none,release.
379 Flags are: assert,df,fold,gc,gcac,gimple,misc,
380 rtlflag,rtl,runtime,tree,valgrind,types])],
381 [ac_checking_flags="${enableval}"],[
382 # Determine the default checks.
383 if test x$is_release = x ; then
384 ac_checking_flags=yes
386 ac_checking_flags=release
388 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
389 for check in release $ac_checking_flags
392 # these set all the flags to specific states
393 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
394 ac_fold_checking= ; ac_gc_checking=1 ;
395 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
396 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
397 ac_tree_checking=1 ; ac_valgrind_checking= ;
398 ac_types_checking=1 ;;
399 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
400 ac_fold_checking= ; ac_gc_checking= ;
401 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
402 ac_rtlflag_checking= ; ac_runtime_checking= ;
403 ac_tree_checking= ; ac_valgrind_checking= ;
404 ac_types_checking= ;;
405 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
406 ac_fold_checking=1 ; ac_gc_checking=1 ;
407 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
408 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
409 ac_tree_checking=1 ; ac_valgrind_checking= ;
410 ac_types_checking=1 ;;
411 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
412 ac_fold_checking= ; ac_gc_checking= ;
413 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
414 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
415 ac_tree_checking= ; ac_valgrind_checking= ;
416 ac_types_checking= ;;
417 # these enable particular checks
418 assert) ac_assert_checking=1 ;;
419 df) ac_df_checking=1 ;;
420 fold) ac_fold_checking=1 ;;
421 gc) ac_gc_checking=1 ;;
422 gcac) ac_gc_always_collect=1 ;;
423 gimple) ac_gimple_checking=1 ;;
424 misc) ac_checking=1 ;;
425 rtl) ac_rtl_checking=1 ;;
426 rtlflag) ac_rtlflag_checking=1 ;;
427 runtime) ac_runtime_checking=1 ;;
428 tree) ac_tree_checking=1 ;;
429 types) ac_types_checking=1 ;;
430 valgrind) ac_valgrind_checking=1 ;;
431 *) AC_MSG_ERROR(unknown check category $check) ;;
437 if test x$ac_checking != x ; then
438 AC_DEFINE(ENABLE_CHECKING, 1,
439 [Define if you want more run-time sanity checks. This one gets a grab
440 bag of miscellaneous but relatively cheap checks.])
441 nocommon_flag=-fno-common
443 AC_SUBST(nocommon_flag)
444 if test x$ac_df_checking != x ; then
445 AC_DEFINE(ENABLE_DF_CHECKING, 1,
446 [Define if you want more run-time sanity checks for dataflow.])
448 if test x$ac_assert_checking != x ; then
449 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
450 [Define if you want assertions enabled. This is a cheap check.])
452 if test x$ac_gimple_checking != x ; then
453 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
454 [Define if you want operations on GIMPLE (the basic data structure of
455 the high-level optimizers) to be checked for dynamic type safety at
456 runtime. This is moderately expensive.])
458 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
459 if test x$ac_runtime_checking != x ; then
460 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
461 [Define if you want runtime assertions enabled. This is a cheap check.])
463 if test x$ac_tree_checking != x ; then
464 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
465 [Define if you want all operations on trees (the basic data
466 structure of the front ends) to be checked for dynamic type safety
467 at runtime. This is moderately expensive. The tree browser debugging
468 routines will also be enabled by this option.
470 TREEBROWSER=tree-browser.o
473 if test x$ac_types_checking != x ; then
474 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
475 [Define if you want all gimple types to be verified after gimplifiation.
479 AC_SUBST(TREEBROWSER)
480 AC_SUBST(TREECHECKING)
481 if test x$ac_rtl_checking != x ; then
482 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
483 [Define if you want all operations on RTL (the basic data structure
484 of the optimizer and back end) to be checked for dynamic type safety
485 at runtime. This is quite expensive.])
487 if test x$ac_rtlflag_checking != x ; then
488 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
489 [Define if you want RTL flag accesses to be checked against the RTL
490 codes that are supported for each access macro. This is relatively
493 if test x$ac_gc_checking != x ; then
494 AC_DEFINE(ENABLE_GC_CHECKING, 1,
495 [Define if you want the garbage collector to do object poisoning and
496 other memory allocation checks. This is quite expensive.])
498 if test x$ac_gc_always_collect != x ; then
499 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
500 [Define if you want the garbage collector to operate in maximally
501 paranoid mode, validating the entire heap and collecting garbage at
502 every opportunity. This is extremely expensive.])
504 if test x$ac_fold_checking != x ; then
505 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
506 [Define if you want fold checked that it never destructs its argument.
507 This is quite expensive.])
509 valgrind_path_defines=
512 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
513 dnl # an if statement. This was the source of very frustrating bugs
514 dnl # in converting to autoconf 2.5x!
515 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
517 # It is certainly possible that there's valgrind but no valgrind.h.
518 # GCC relies on making annotations so we must have both.
519 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
520 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
521 [[#include <valgrind/memcheck.h>
522 #ifndef VALGRIND_DISCARD
523 #error VALGRIND_DISCARD not defined
525 [gcc_cv_header_valgrind_memcheck_h=yes],
526 [gcc_cv_header_valgrind_memcheck_h=no])
527 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
528 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
529 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
530 [[#include <memcheck.h>
531 #ifndef VALGRIND_DISCARD
532 #error VALGRIND_DISCARD not defined
534 [gcc_cv_header_memcheck_h=yes],
535 [gcc_cv_header_memcheck_h=no])
536 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
537 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
538 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
539 [Define if valgrind's valgrind/memcheck.h header is installed.])
541 if test $gcc_cv_header_memcheck_h = yes; then
542 AC_DEFINE(HAVE_MEMCHECK_H, 1,
543 [Define if valgrind's memcheck.h header is installed.])
546 if test x$ac_valgrind_checking != x ; then
547 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
548 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
549 if test "x$valgrind_path" = "x" \
550 || (test $have_valgrind_h = no \
551 && test $gcc_cv_header_memcheck_h = no \
552 && test $gcc_cv_header_valgrind_memcheck_h = no); then
553 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
555 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
556 valgrind_command="$valgrind_path -q"
557 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
558 [Define if you want to run subprograms and generated programs
559 through valgrind (a memory checker). This is extremely expensive.])
561 AC_SUBST(valgrind_path_defines)
562 AC_SUBST(valgrind_command)
564 # Enable code coverage collection
565 AC_ARG_ENABLE(coverage,
566 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
567 [enable compiler's code coverage collection.
568 Use to measure compiler performance and locate
569 unused parts of the compiler. With LEVEL, specify
570 optimization. Values are opt, noopt,
572 [case "${enableval}" in
574 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
577 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
580 # a.k.a. --disable-coverage
584 AC_MSG_ERROR(unknown coverage setting $enableval)
588 AC_SUBST(coverage_flags)
590 AC_ARG_ENABLE(gather-detailed-mem-stats,
591 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
592 [enable detailed memory allocation stats gathering])], [],
593 [enable_gather_detailed_mem_stats=no])
594 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
595 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
596 [Define to enable detailed memory allocation stats gathering.])
598 AC_ARG_ENABLE(valgrind-annotations,
599 [AS_HELP_STRING([--enable-valgrind-annotations],
600 [enable valgrind runtime interaction])], [],
601 [enable_valgrind_annotations=no])
602 if test x$enable_valgrind_annotations != xno \
603 || test x$ac_valgrind_checking != x; then
604 if (test $have_valgrind_h = no \
605 && test $gcc_cv_header_memcheck_h = no \
606 && test $gcc_cv_header_valgrind_memcheck_h = no); then
607 AC_MSG_ERROR([*** Can't find valgrind/memcheck.h, memcheck.h or valgrind.h])
609 AC_DEFINE(ENABLE_VALGRIND_ANNOTATIONS, 1,
610 [Define to get calls to the valgrind runtime enabled.])
613 # -------------------------------
614 # Miscenalleous configure options
615 # -------------------------------
619 [AS_HELP_STRING([--with-stabs],
620 [arrange to use stabs instead of host debug format])],
624 # Determine whether or not multilibs are enabled.
625 AC_ARG_ENABLE(multilib,
626 [AS_HELP_STRING([--enable-multilib],
627 [enable library support for multiple ABIs])],
628 [], [enable_multilib=yes])
629 AC_SUBST(enable_multilib)
631 # Determine whether or not multiarch is enabled.
632 AC_ARG_ENABLE(multiarch,
633 [AS_HELP_STRING([--enable-multiarch],
634 [enable support for multiarch paths])],
635 [case "${enableval}" in
636 yes|no|auto) enable_multiarch=$enableval;;
637 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
638 esac], [enable_multiarch=auto])
639 if test x${enable_multiarch} = xauto; then
640 if test x${with_native_system_header_dir} != x; then
641 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
644 if test x$host != x$target && test "x$with_sysroot" = x; then
645 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
649 AC_MSG_CHECKING(for multiarch configuration)
650 AC_SUBST(enable_multiarch)
651 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
653 # needed for setting the multiarch name for soft-float/hard-float ABIs
657 # Enable __cxa_atexit for C++.
658 AC_ARG_ENABLE(__cxa_atexit,
659 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
662 # Enable C extension for decimal float if target supports it.
663 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
665 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
666 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
667 [Define to 1 to enable decimal float extension to C.])
669 # Use default_decimal_float for dependency.
670 enable_decimal_float=$default_decimal_float
672 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
673 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
674 [Define to 1 to specify that we are using the BID decimal floating
675 point format instead of DPD])
677 # Enable C extension for fixed-point arithmetic.
678 AC_ARG_ENABLE(fixed-point,
679 [AS_HELP_STRING([--enable-fixed-point],
680 [enable fixed-point arithmetic extension to C])],
685 enable_fixed_point=yes
689 enable_fixed_point=yes
692 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
693 enable_fixed_point=no
697 AC_SUBST(enable_fixed_point)
699 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
700 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
701 [Define to 1 to enable fixed-point arithmetic extension to C.])
704 # Pass with no value to take the default
705 # Pass with a value to specify a thread package
706 AC_ARG_ENABLE(threads,
707 [AS_HELP_STRING([[--enable-threads[=LIB]]],
708 [enable thread usage for target GCC,
709 using LIB thread package])],,
713 [AS_HELP_STRING([--enable-tls],
714 [enable or disable generation of tls code
715 overriding the assembler check for tls support])],
719 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
720 Valid choices are 'yes' and 'no'.]) ;;
724 AC_ARG_ENABLE(objc-gc,
725 [AS_HELP_STRING([--enable-objc-gc],
726 [enable the use of Boehm's garbage collector with
727 the GNU Objective-C runtime])],
728 if test x$enable_objc_gc = xno; then
736 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
737 dwarf2="$with_dwarf2",
740 AC_ARG_ENABLE(shared,
741 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
743 case $enable_shared in
747 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
748 for pkg in $enableval; do
749 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
756 ], [enable_shared=yes])
757 AC_SUBST(enable_shared)
759 AC_ARG_WITH([native-system-header-dir],
760 [ --with-native-system-header-dir=dir
761 use dir as the directory to look for standard
762 system header files in. Defaults to /usr/include.],
764 case ${with_native_system_header_dir} in
765 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
766 /* | [[A-Za-z]]:[[\\/]]*) ;;
767 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
769 configured_native_system_header_dir="${withval}"
770 ], [configured_native_system_header_dir=])
772 AC_ARG_WITH(build-sysroot,
773 [AS_HELP_STRING([--with-build-sysroot=sysroot],
774 [use sysroot as the system root during the build])],
775 [if test x"$withval" != x ; then
776 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
778 [SYSROOT_CFLAGS_FOR_TARGET=])
779 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
781 if test "x$prefix" = xNONE; then
782 test_prefix=/usr/local
786 if test "x$exec_prefix" = xNONE; then
787 test_exec_prefix=$test_prefix
789 test_exec_prefix=$exec_prefix
793 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
794 [search for usr/lib, usr/include, et al, within DIR])],
796 case ${with_sysroot} in
797 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
798 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
801 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
802 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
804 case ${TARGET_SYSTEM_ROOT} in
805 "${test_prefix}"|"${test_prefix}/"*|\
806 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
807 '${prefix}'|'${prefix}/'*|\
808 '${exec_prefix}'|'${exec_prefix}/'*)
809 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
810 TARGET_SYSTEM_ROOT_DEFINE="$t"
815 TARGET_SYSTEM_ROOT_DEFINE=
816 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
818 AC_SUBST(TARGET_SYSTEM_ROOT)
819 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
820 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
823 [AS_HELP_STRING([--with-specs=SPECS],
824 [add SPECS to driver command-line processing])],
825 [CONFIGURE_SPECS=$withval],
828 AC_SUBST(CONFIGURE_SPECS)
830 ACX_PKGVERSION([GCC])
831 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
833 # Sanity check enable_languages in case someone does not run the toplevel
834 # configure # script.
835 AC_ARG_ENABLE(languages,
836 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
837 [case ,${enable_languages}, in
839 # go safe -- we cannot be much sure without the toplevel
841 # analysis of which target libs are present and usable
845 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
850 enable_languages=c,${enable_languages}
853 [enable_languages=c])
855 AC_ARG_WITH(multilib-list,
856 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
858 with_multilib_list=default)
860 # -------------------------
861 # Checks for other programs
862 # -------------------------
866 # Find some useful tools
868 # We need awk to create options.c and options.h.
869 # Bail out if it's missing.
871 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
878 AC_SUBST(ranlib_flags)
882 # See if cmp has --ignore-initial.
883 gcc_AC_PROG_CMP_IGNORE_INITIAL
885 # See if we have the mktemp command.
886 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
888 # See if makeinfo has been installed and is modern enough
889 # that we can use it.
890 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
891 [GNU texinfo.* \([0-9][0-9.]*\)],
892 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
893 if test $gcc_cv_prog_makeinfo_modern = no; then
895 *** Makeinfo is missing or too old.
896 *** Info documentation will not be built.])
903 # Is pod2man recent enough to regenerate manpages?
904 AC_MSG_CHECKING([for recent Pod::Man])
905 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
907 GENERATED_MANPAGES=generated-manpages
912 AC_SUBST(GENERATED_MANPAGES)
914 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
917 dnl Don't use AC_PROG_LEX; we insist on flex.
918 dnl LEXLIB is not useful in gcc.
919 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
922 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
924 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
925 # check for build == host before using them.
928 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
929 && test -d ../binutils ; then
930 NM='${objdir}/../binutils/nm-new'
932 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
936 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
937 && test -d ../binutils ; then
938 AR='${objdir}/../binutils/ar'
940 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
944 # --------------------
945 # Checks for C headers
946 # --------------------
948 # Need to reject headers which give warnings, so that the -Werror bootstrap
949 # works later. *sigh* This needs to come before all header checks.
957 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
958 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
959 sys/resource.h sys/param.h sys/times.h sys/stat.h \
960 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
962 # Check for thread headers.
963 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
964 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
966 # These tests can't be done till we know if we have limits.h.
970 # ----------------------
971 # Checks for C++ headers
972 # ----------------------
974 dnl Autoconf will give an error in the configure script if there is no
975 dnl C++ preprocessor. Hack to prevent that.
976 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
978 m4_popdef([AC_MSG_ERROR])[]dnl
982 AC_CHECK_HEADERS(unordered_map)
983 AC_CHECK_HEADERS(tr1/unordered_map)
984 AC_CHECK_HEADERS(ext/hash_map)
989 # Dependency checking.
994 AC_CONFIG_COMMANDS([gccdepdir],[
995 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
996 for lang in $subdirs c-family common
998 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
999 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1001 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1009 # These libraries may be used by collect2.
1010 # We may need a special search path to get them linked.
1011 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1013 for libs in '' -lld -lmld \
1014 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1015 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1018 AC_TRY_LINK_FUNC(ldopen,
1019 [gcc_cv_collect2_libs="$libs"; break])
1022 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1023 case $gcc_cv_collect2_libs in
1025 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1027 AC_SUBST(COLLECT2_LIBS)
1029 # When building Ada code on Alpha, we need exc_resume which is usually in
1030 # -lexc. So test for it.
1033 AC_SEARCH_LIBS(exc_resume, exc)
1036 AC_SUBST(GNAT_LIBEXC)
1038 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1041 AC_SEARCH_LIBS(kstat_open, kstat)
1042 EXTRA_GCC_LIBS="$LIBS"
1044 AC_SUBST(EXTRA_GCC_LIBS)
1046 # Some systems put ldexp and frexp in libm instead of libc; assume
1047 # they're both in the same place. jcf-dump needs them.
1050 AC_SEARCH_LIBS(ldexp, m)
1055 # Use <inttypes.h> only if it exists,
1056 # doesn't clash with <sys/types.h>, and declares intmax_t.
1057 AC_MSG_CHECKING(for inttypes.h)
1058 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1059 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1060 [[#include <sys/types.h>
1061 #include <inttypes.h>]],
1062 [[intmax_t i = -1;]])],
1063 [gcc_cv_header_inttypes_h=yes],
1064 [gcc_cv_header_inttypes_h=no])])
1065 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1066 if test $gcc_cv_header_inttypes_h = yes; then
1067 AC_DEFINE(HAVE_INTTYPES_H, 1,
1068 [Define if you have a working <inttypes.h> header file.])
1071 dnl Disabled until we have a complete test for buggy enum bitfields.
1072 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1074 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1075 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1076 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1077 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1078 putchar_unlocked putc_unlocked)
1079 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1080 sysconf strsignal getrusage nl_langinfo \
1081 gettimeofday mbstowcs wcswidth mmap setlocale \
1082 gcc_UNLOCKED_FUNCS madvise)
1084 if test x$ac_cv_func_mbstowcs = xyes; then
1085 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1086 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1092 [gcc_cv_func_mbstowcs_works=yes],
1093 [gcc_cv_func_mbstowcs_works=no],
1094 [gcc_cv_func_mbstowcs_works=yes])])
1095 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1096 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1097 [Define this macro if mbstowcs does not crash when its
1098 first argument is NULL.])
1102 AC_CHECK_TYPE(ssize_t, int)
1103 AC_CHECK_TYPE(caddr_t, char *)
1105 GCC_AC_FUNC_MMAP_BLACKLIST
1109 # Under VMS, vfork works very differently than on Unix. The standard test
1110 # won't work, and it isn't easily adaptable. It makes more sense to
1112 ac_cv_func_vfork_works=yes
1117 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1118 # iconv() prototype.
1123 # Until we have in-tree GNU iconv:
1125 AC_SUBST(LIBICONV_DEP)
1131 # We will need to find libiberty.h and ansidecl.h
1132 saved_CFLAGS="$CFLAGS"
1133 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1134 saved_CXXFLAGS="$CXXFLAGS"
1135 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1136 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1137 strsignal strstr stpcpy strverscmp \
1138 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1139 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1140 #include "ansidecl.h"
1141 #include "system.h"])
1143 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1144 #include "ansidecl.h"
1146 #ifdef HAVE_SYS_RESOURCE_H
1147 #include <sys/resource.h>
1151 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1152 #include "ansidecl.h"
1154 #ifdef HAVE_SYS_RESOURCE_H
1155 #include <sys/resource.h>
1157 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1158 [Define to `long' if <sys/resource.h> doesn't define.])])
1160 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1161 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1162 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1163 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1164 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1165 #include "ansidecl.h"
1174 gcc_AC_CHECK_DECLS(times, , ,[
1175 #include "ansidecl.h"
1177 #ifdef HAVE_SYS_TIMES_H
1178 #include <sys/times.h>
1182 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1183 #include "ansidecl.h"
1188 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1191 gcc_AC_CHECK_DECLS(madvise, , ,[
1192 #include "ansidecl.h"
1197 # More time-related stuff.
1198 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1199 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1200 #include "ansidecl.h"
1202 #ifdef HAVE_SYS_TIMES_H
1203 #include <sys/times.h>
1205 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1206 if test $ac_cv_struct_tms = yes; then
1207 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1208 [Define if <sys/times.h> defines struct tms.])
1211 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1212 # revisit after autoconf 2.50.
1213 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1214 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1215 #include "ansidecl.h"
1217 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1218 if test $gcc_cv_type_clock_t = yes; then
1219 AC_DEFINE(HAVE_CLOCK_T, 1,
1220 [Define if <time.h> defines clock_t.])
1223 # Check if F_SETLKW is supported by fcntl.
1224 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1225 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1226 #include <fcntl.h>]], [[
1232 return fcntl (1, F_SETLKW, &fl);]])],
1233 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1234 if test $ac_cv_f_setlkw = yes; then
1235 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1236 [Define if F_SETLKW supported by fcntl.])
1239 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1240 CFLAGS="$saved_CFLAGS"
1241 CXXFLAGS="$saved_CXXFLAGS"
1243 # mkdir takes a single argument on some systems.
1244 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1252 # With Setjmp/Longjmp based exception handling.
1253 AC_ARG_ENABLE(sjlj-exceptions,
1254 [AS_HELP_STRING([--enable-sjlj-exceptions],
1255 [arrange to use setjmp/longjmp exception handling])],
1258 if test $enableval != yes; then
1259 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1264 force_sjlj_exceptions=yes],
1267 force_sjlj_exceptions=yes
1271 force_sjlj_exceptions=yes
1275 force_sjlj_exceptions=no
1278 if test $force_sjlj_exceptions = yes; then
1279 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1280 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1281 [Define 0/1 to force the choice for exception handling model.])
1284 # --------------------------------------------------------
1285 # Build, host, and target specific configuration fragments
1286 # --------------------------------------------------------
1288 # Collect build-machine-specific information.
1289 . ${srcdir}/config.build
1291 # Collect host-machine-specific information.
1292 . ${srcdir}/config.host
1296 # Collect target-machine-specific information.
1297 . ${srcdir}/config.gcc
1299 extra_objs="${host_extra_objs} ${extra_objs}"
1300 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1302 # Default the target-machine variables that were not explicitly set.
1303 if test x"$tm_file" = x
1304 then tm_file=$cpu_type/$cpu_type.h; fi
1306 if test x"$extra_headers" = x
1307 then extra_headers=; fi
1309 if test x$md_file = x
1310 then md_file=$cpu_type/$cpu_type.md; fi
1312 if test x$out_file = x
1313 then out_file=$cpu_type/$cpu_type.c; fi
1315 if test x"$tmake_file" = x
1316 then tmake_file=$cpu_type/t-$cpu_type
1319 # Support --enable-initfini-array.
1320 if test x$enable_initfini_array != xno; then
1321 tm_file="${tm_file} initfini-array.h"
1324 if test x"$dwarf2" = xyes
1325 then tm_file="$tm_file tm-dwarf2.h"
1328 # Say what files are being used for the output code and MD file.
1329 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1330 echo "Using \`$srcdir/config/$md_file' as machine description file."
1332 # If any of the xm_file variables contain nonexistent files, warn
1333 # about them and drop them.
1336 for x in $build_xm_file; do
1337 if test -f $srcdir/config/$x
1339 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1345 for x in $host_xm_file; do
1346 if test -f $srcdir/config/$x
1348 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1354 for x in $xm_file; do
1355 if test -f $srcdir/config/$x
1357 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1363 for f in $tm_file; do
1366 if test $count = ax; then
1367 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1369 echo "Using the following target machine macro files:"
1370 for f in $tm_file; do
1371 echo " $srcdir/config/$f"
1375 if test x$use_long_long_for_widest_fast_int = xyes; then
1376 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1377 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1378 efficiently supported by the host hardware.])
1381 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1382 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1384 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1385 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1388 for f in $host_xm_file; do
1391 if test $count = a; then
1393 elif test $count = ax; then
1394 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1396 echo "Using the following host machine macro files:"
1397 for f in $host_xm_file; do
1398 echo " $srcdir/config/$f"
1401 echo "Using ${out_host_hook_obj} for host machine hooks."
1403 if test "$host_xm_file" != "$build_xm_file"; then
1405 for f in $build_xm_file; do
1408 if test $count = a; then
1410 elif test $count = ax; then
1411 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1413 echo "Using the following build machine macro files:"
1414 for f in $build_xm_file; do
1415 echo " $srcdir/config/$f"
1420 if test -n "$configured_native_system_header_dir"; then
1421 native_system_header_dir=$configured_native_system_header_dir
1423 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1424 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1428 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1429 gcc_cv_mcontext_underscores,
1431 #include <sys/cdefs.h>
1432 #include <sys/signal.h>
1433 #include <ucontext.h>
1434 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1436 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1437 if test $gcc_cv_mcontext_underscores = yes; then
1438 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1439 [mcontext_t fields start with __])
1448 # Check if a valid thread package
1449 case ${enable_threads} in
1452 target_thread_file='single'
1456 target_thread_file='single'
1458 aix | dce | lynx | mipssde | posix | rtems | \
1459 single | tpf | vxworks | win32)
1460 target_thread_file=${enable_threads}
1463 echo "${enable_threads} is an unknown thread package" 1>&2
1468 if test x${thread_file} = x; then
1469 # No thread file set by target-specific clauses in config.gcc,
1470 # so use file chosen by default logic above
1471 thread_file=${target_thread_file}
1479 if test x$enable___cxa_atexit = xyes || \
1480 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1481 if test x$host = x$target; then
1483 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1484 # keyed to flag_use_cxa_atexit
1492 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1493 [echo "__cxa_atexit can't be enabled on this target"])
1497 # We can't check for __cxa_atexit when building a cross, so assume
1501 if test x$use_cxa_atexit = xyes; then
1502 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1503 [Define if you want to use __cxa_atexit, rather than atexit, to
1504 register C++ destructors for local statics and global objects.
1505 This is essential for fully standards-compliant handling of
1506 destructors, but requires __cxa_atexit in libc.])
1510 # Look for a file containing extra machine modes.
1511 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1512 extra_modes_file='$(srcdir)'/config/${extra_modes}
1513 AC_SUBST(extra_modes_file)
1514 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1515 [Define to the name of a file containing a list of extra machine modes
1516 for this architecture.])
1519 # Convert extra_options into a form suitable for Makefile use.
1522 for f in $extra_options; do
1523 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1524 all_opt_files="$all_opt_files $srcdir/config/$f"
1526 AC_SUBST(extra_opt_files)
1528 # auto-host.h is the file containing items generated by autoconf and is
1529 # the first file included by config.h.
1530 # If host=build, it is correct to have bconfig include auto-host.h
1531 # as well. If host!=build, we are in error and need to do more
1532 # work to find out the build config parameters.
1533 if test x$host = x$build
1535 build_auto=auto-host.h
1537 # We create a subdir, then run autoconf in the subdir.
1538 # To prevent recursion we set host and build for the new
1539 # invocation of configure to the build for this invocation
1546 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1547 *) realsrcdir=../${srcdir};;
1549 # Clearing GMPINC is necessary to prevent host headers being
1550 # used by the build compiler. Defining GENERATOR_FILE stops
1551 # system.h from including gmp.h.
1552 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1553 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1554 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1555 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1556 ${realsrcdir}/configure \
1557 --enable-languages=${enable_languages-all} \
1558 --target=$target_alias --host=$build_alias --build=$build_alias
1560 # We just finished tests for the build machine, so rename
1561 # the file auto-build.h in the gcc directory.
1562 mv auto-host.h ../auto-build.h
1565 build_auto=auto-build.h
1567 AC_SUBST(build_subdir)
1569 tm_file="${tm_file} defaults.h"
1570 tm_p_file="${tm_p_file} tm-preds.h"
1571 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1572 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1573 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1574 # put this back in temporarily.
1575 xm_file="auto-host.h ansidecl.h ${xm_file}"
1582 # Compile in configure arguments.
1583 if test -f configargs.h ; then
1584 # Being re-configured.
1585 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1586 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1588 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1591 # Double all backslashes and backslash all quotes to turn
1592 # gcc_config_arguments into a C string.
1593 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1594 $gcc_config_arguments
1596 gcc_config_arguments_str=`cat conftest.out`
1599 cat > configargs.h <<EOF
1600 /* Generated automatically. */
1601 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1602 static const char thread_model[] = "$thread_file";
1604 static const struct {
1605 const char *name, *value;
1606 } configure_default_options[] = $configure_default_options;
1611 gcc_BASEVER=`cat $srcdir/BASE-VER`
1612 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1613 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1614 if test -f $srcdir/REVISION ; then
1615 gcc_REVISION=`cat $srcdir/REVISION`
1619 cat > plugin-version.h <<EOF
1620 #include "configargs.h"
1622 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1623 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1624 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1625 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1627 static char basever[] = "$gcc_BASEVER";
1628 static char datestamp[] = "$gcc_DATESTAMP";
1629 static char devphase[] = "$gcc_DEVPHASE";
1630 static char revision[] = "$gcc_REVISION";
1632 /* FIXME plugins: We should make the version information more precise.
1633 One way to do is to add a checksum. */
1635 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1637 configuration_arguments};
1641 # Internationalization
1642 ZW_GNU_GETTEXT_SISTER_DIR
1644 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1645 # -liconv on the link line twice.
1646 case "$LIBINTL" in *$LIBICONV*)
1650 AC_ARG_ENABLE(secureplt,
1651 [AS_HELP_STRING([--enable-secureplt],
1652 [enable -msecure-plt by default for PowerPC])],
1655 AC_ARG_ENABLE(leading-mingw64-underscores,
1656 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1657 [enable leading underscores on 64 bit mingw targets]),
1659 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1660 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1661 [Define if we should use leading underscore on 64 bit mingw targets])])
1664 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1667 AC_ARG_ENABLE(frame-pointer,
1668 [AS_HELP_STRING([--enable-frame-pointer],
1669 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1672 linux* | darwin[[8912]]*)
1673 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1675 enable_frame_pointer=no
1678 enable_frame_pointer=yes
1683 # Windows32 Registry support for specifying GCC installation paths.
1684 AC_ARG_ENABLE(win32-registry,
1685 [AS_HELP_STRING([--disable-win32-registry],
1686 [disable lookup of installation paths in the
1687 Registry on Windows hosts])
1688 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1689 AS_HELP_STRING([--enable-win32-registry=KEY],
1690 [use KEY instead of GCC version as the last portion
1691 of the registry key])],,)
1694 win32 | pe | cygwin* | mingw32* | uwin*)
1695 if test "x$enable_win32_registry" != xno; then
1696 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1699 if test "x$enable_win32_registry" != xno; then
1700 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1701 [Define to 1 if installation paths should be looked up in the Windows
1702 Registry. Ignored on non-Windows hosts.])
1704 if test "x$enable_win32_registry" != xyes \
1705 && test "x$enable_win32_registry" != x; then
1706 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1707 [Define to be the last component of the Windows registry key under which
1708 to look for installation paths. The full key used will be
1709 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1710 The default is the GCC version number.])
1716 # Get an absolute path to the GCC top-level source directory
1717 holddir=`${PWDCMD-pwd}`
1719 topdir=`${PWDCMD-pwd}`
1722 # Conditionalize the makefile for this host machine.
1724 for f in ${host_xmake_file}
1726 if test -f ${srcdir}/config/$f
1728 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1732 # Conditionalize the makefile for this target machine.
1734 for f in ${tmake_file}
1736 if test -f ${srcdir}/config/$f
1738 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1741 tmake_file="${tmake_file_}"
1743 out_object_file=`basename $out_file .c`.o
1744 common_out_object_file=`basename $common_out_file .c`.o
1746 tm_file_list="options.h"
1747 tm_include_list="options.h insn-constants.h"
1748 for f in $tm_file; do
1751 f=`echo $f | sed 's/^..//'`
1752 tm_file_list="${tm_file_list} $f"
1753 tm_include_list="${tm_include_list} $f"
1756 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1757 tm_include_list="${tm_include_list} $f"
1760 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1761 tm_include_list="${tm_include_list} config/$f"
1768 for f in $tm_p_file; do
1771 tm_p_file_list="${tm_p_file_list} $f"
1772 tm_p_include_list="${tm_p_include_list} $f"
1775 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1776 tm_p_include_list="${tm_p_include_list} config/$f"
1782 for f in $xm_file; do
1785 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1786 xm_include_list="${xm_include_list} $f"
1789 xm_file_list="${xm_file_list} $f"
1790 xm_include_list="${xm_include_list} $f"
1793 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1794 xm_include_list="${xm_include_list} config/$f"
1800 host_xm_include_list=
1801 for f in $host_xm_file; do
1804 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1805 host_xm_include_list="${host_xm_include_list} $f"
1808 host_xm_file_list="${host_xm_file_list} $f"
1809 host_xm_include_list="${host_xm_include_list} $f"
1812 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1813 host_xm_include_list="${host_xm_include_list} config/$f"
1819 for f in $build_xm_file; do
1822 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1823 build_xm_include_list="${build_xm_include_list} $f"
1825 auto-build.h | auto-host.h )
1826 build_xm_file_list="${build_xm_file_list} $f"
1827 build_xm_include_list="${build_xm_include_list} $f"
1830 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1831 build_xm_include_list="${build_xm_include_list} config/$f"
1836 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1837 # cross-compiler which does not use the native headers and libraries.
1838 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1839 CROSS= AC_SUBST(CROSS)
1840 ALL=all.internal AC_SUBST(ALL)
1841 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1843 if test "x$with_build_sysroot" != x; then
1844 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1846 # This value is used, even on a native system, because
1847 # CROSS_SYSTEM_HEADER_DIR is just
1848 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1849 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1852 if test x$host != x$target
1854 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1856 SYSTEM_HEADER_DIR=$build_system_header_dir
1857 case "$host","$target" in
1858 # Darwin crosses can use the host system's libraries and headers,
1859 # because of the fat library support. Of course, it must be the
1860 # same version of Darwin on both sides. Allow the user to
1861 # just say --target=foo-darwin without a version number to mean
1862 # "the version on this system".
1863 *-*-darwin*,*-*-darwin*)
1864 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1865 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1866 if test $hostos = $targetos -o $targetos = darwin ; then
1868 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1873 i?86-*-*,x86_64-*-* \
1874 | powerpc*-*-*,powerpc64*-*-*)
1875 CROSS="$CROSS -DNATIVE_CROSS" ;;
1880 if test "x$with_headers" = x; then
1887 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1888 SYSTEM_HEADER_DIR=$build_system_header_dir
1891 # If this is a cross-compiler that does not
1892 # have its own set of headers then define
1895 # If this is using newlib, without having the headers available now,
1896 # then define inhibit_libc in LIBGCC2_CFLAGS.
1897 # This prevents libgcc2 from containing any code which requires libc
1899 : ${inhibit_libc=false}
1900 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1901 test x$with_newlib = xyes ; } &&
1902 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1905 AC_SUBST(inhibit_libc)
1907 # When building gcc with a cross-compiler, we need to adjust things so
1908 # that the generator programs are still built with the native compiler.
1909 # Also, we cannot run fixincludes.
1911 # These are the normal (build=host) settings:
1912 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1913 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1914 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1915 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1916 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1917 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1919 # And these apply if build != host, or we are generating coverage data
1920 if test x$build != x$host || test "x$coverage_flags" != x
1922 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1923 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1924 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1927 # Expand extra_headers to include complete path.
1928 # This substitutes for lots of t-* files.
1930 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1931 for file in ${extra_headers} ; do
1932 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1935 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1936 if test x"$use_gcc_tgmath" = xyes
1937 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1940 # Define collect2 in Makefile.
1941 case $host_can_use_collect2 in
1943 *) collect2='collect2$(exeext)' ;;
1945 AC_SUBST([collect2])
1947 # Add a definition of USE_COLLECT2 if system wants one.
1948 case $use_collect2 in
1949 no) use_collect2= ;;
1952 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1953 xm_defines="${xm_defines} USE_COLLECT2"
1954 case $host_can_use_collect2 in
1956 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1962 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1963 [Define to the name of the LTO plugin DSO that must be
1964 passed to the linker's -plugin=LIB option.])
1966 # ---------------------------
1967 # Assembler & linker features
1968 # ---------------------------
1970 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1971 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1972 # However when ld-new is first executed from the build tree, libtool will
1973 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1974 # to the build tree. While doing this we need to use the previous-stage
1975 # linker, or we have an infinite loop. The presence of a shell script as
1976 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1977 # the gcc/collect-ld script. So we need to know how libtool works, or
1978 # exec-tool will fail.
1980 m4_defun([_LT_CONFIG_COMMANDS], [])
1983 AC_SUBST(enable_fast_install)
1985 # Identify the assembler which will work hand-in-glove with the newly
1986 # built GCC, so that we can examine its features. This is the assembler
1987 # which will be driven by the driver program.
1989 # If build != host, and we aren't building gas in-tree, we identify a
1990 # build->target assembler and hope that it will have the same features
1991 # as the host->target assembler we'll be using.
1992 gcc_cv_gas_major_version=
1993 gcc_cv_gas_minor_version=
1994 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1996 m4_pattern_allow([AS_FOR_TARGET])dnl
1997 AS_VAR_SET_IF(gcc_cv_as,, [
1998 if test -x "$DEFAULT_ASSEMBLER"; then
1999 gcc_cv_as="$DEFAULT_ASSEMBLER"
2000 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2001 && test -f ../gas/Makefile \
2002 && test x$build = x$host; then
2003 gcc_cv_as=../gas/as-new$build_exeext
2004 elif test -x as$build_exeext; then
2005 # Build using assembler in the current directory.
2006 gcc_cv_as=./as$build_exeext
2007 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2008 gcc_cv_as="$AS_FOR_TARGET"
2010 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2013 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2014 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2015 case "$ORIGINAL_AS_FOR_TARGET" in
2016 ./as | ./as$build_exeext) ;;
2017 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2020 AC_MSG_CHECKING(what assembler to use)
2021 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2022 # Single tree build which includes gas. We want to prefer it
2023 # over whatever linker top-level may have detected, since
2024 # we'll use what we're building after installation anyway.
2025 AC_MSG_RESULT(newly built gas)
2027 _gcc_COMPUTE_GAS_VERSION
2028 in_tree_gas_is_elf=no
2029 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2030 || (grep 'obj_format = multi' ../gas/Makefile \
2031 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2033 in_tree_gas_is_elf=yes
2036 AC_MSG_RESULT($gcc_cv_as)
2042 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2043 [case "${enableval}" in
2050 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2051 [case "${enableval}" in
2053 install_gold_as_default=yes
2056 if test x${default_ld} != x; then
2057 install_gold_as_default=yes
2063 AC_MSG_ERROR([invalid --enable-gold argument])
2066 [install_gold_as_default=no])
2068 # Identify the linker which will work hand-in-glove with the newly
2069 # built GCC, so that we can examine its features. This is the linker
2070 # which will be driven by the driver program.
2072 # If build != host, and we aren't building gas in-tree, we identify a
2073 # build->target linker and hope that it will have the same features
2074 # as the host->target linker we'll be using.
2075 gcc_cv_gld_major_version=
2076 gcc_cv_gld_minor_version=
2077 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2078 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2079 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2081 AS_VAR_SET_IF(gcc_cv_ld,, [
2082 if test -x "$DEFAULT_LINKER"; then
2083 gcc_cv_ld="$DEFAULT_LINKER"
2084 elif test $install_gold_as_default = yes \
2085 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2086 && test -f ../gold/Makefile \
2087 && test x$build = x$host; then
2088 gcc_cv_ld=../gold/ld-new$build_exeext
2089 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2090 && test -f ../ld/Makefile \
2091 && test x$build = x$host; then
2092 gcc_cv_ld=../ld/ld-new$build_exeext
2093 elif test -x collect-ld$build_exeext; then
2094 # Build using linker in the current directory.
2095 gcc_cv_ld=./collect-ld$build_exeext
2096 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2097 gcc_cv_ld="$LD_FOR_TARGET"
2099 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2102 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2103 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2104 # if the PLUGIN_LD is set ld-new, just have it as ld
2105 # as that is the installed named.
2106 if test x$PLUGIN_LD_SUFFIX = xld-new \
2107 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2110 AC_ARG_WITH(plugin-ld,
2111 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2112 [if test x"$withval" != x; then
2113 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2114 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2116 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2117 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2119 # Check to see if we are using gold instead of ld
2120 AC_MSG_CHECKING(whether we are using gold)
2122 if test x$gcc_cv_ld != x; then
2123 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2124 | grep "GNU gold" > /dev/null; then
2128 AC_MSG_RESULT($ld_is_gold)
2130 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2131 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2132 case "$ORIGINAL_LD_FOR_TARGET" in
2133 ./collect-ld | ./collect-ld$build_exeext) ;;
2134 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2137 AC_MSG_CHECKING(what linker to use)
2138 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2139 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2140 # Single tree build which includes ld. We want to prefer it
2141 # over whatever linker top-level may have detected, since
2142 # we'll use what we're building after installation anyway.
2143 AC_MSG_RESULT(newly built ld)
2145 in_tree_ld_is_elf=no
2146 if (grep 'EMUL = .*elf' ../ld/Makefile \
2147 || grep 'EMUL = .*linux' ../ld/Makefile \
2148 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2149 in_tree_ld_is_elf=yes
2150 elif test "$ld_is_gold" = yes; then
2151 in_tree_ld_is_elf=yes
2153 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
2156 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2157 if test x$gcc_cv_gld_version != x; then
2161 case $gcc_cv_gld_version in
2164 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2167 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2168 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2170 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2171 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2173 AC_MSG_RESULT($gcc_cv_ld)
2175 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2176 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2177 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2180 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2181 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2183 # Figure out what nm we will be using.
2184 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2185 AS_VAR_SET_IF(gcc_cv_nm,, [
2186 if test -f $gcc_cv_binutils_srcdir/configure.in \
2187 && test -f ../binutils/Makefile \
2188 && test x$build = x$host; then
2189 gcc_cv_nm=../binutils/nm-new$build_exeext
2190 elif test -x nm$build_exeext; then
2191 gcc_cv_nm=./nm$build_exeext
2192 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2193 gcc_cv_nm="$NM_FOR_TARGET"
2195 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2198 AC_MSG_CHECKING(what nm to use)
2199 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2200 # Single tree build which includes binutils.
2201 AC_MSG_RESULT(newly built nm)
2204 AC_MSG_RESULT($gcc_cv_nm)
2208 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2209 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2210 case "$ORIGINAL_NM_FOR_TARGET" in
2211 ./nm | ./nm$build_exeext) ;;
2212 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2216 # Figure out what objdump we will be using.
2217 AS_VAR_SET_IF(gcc_cv_objdump,, [
2218 if test -f $gcc_cv_binutils_srcdir/configure.in \
2219 && test -f ../binutils/Makefile \
2220 && test x$build = x$host; then
2221 # Single tree build which includes binutils.
2222 gcc_cv_objdump=../binutils/objdump$build_exeext
2223 elif test -x objdump$build_exeext; then
2224 gcc_cv_objdump=./objdump$build_exeext
2225 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2226 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2228 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2231 AC_MSG_CHECKING(what objdump to use)
2232 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2233 # Single tree build which includes binutils.
2234 AC_MSG_RESULT(newly built objdump)
2235 elif test x$gcc_cv_objdump = x; then
2236 AC_MSG_RESULT(not found)
2238 AC_MSG_RESULT($gcc_cv_objdump)
2241 # Figure out what readelf we will be using.
2242 AS_VAR_SET_IF(gcc_cv_readelf,, [
2243 if test -f $gcc_cv_binutils_srcdir/configure.in \
2244 && test -f ../binutils/Makefile \
2245 && test x$build = x$host; then
2246 # Single tree build which includes binutils.
2247 gcc_cv_readelf=../binutils/readelf$build_exeext
2248 elif test -x readelf$build_exeext; then
2249 gcc_cv_readelf=./readelf$build_exeext
2251 AC_PATH_PROG(gcc_cv_readelf, readelf)
2254 AC_MSG_CHECKING(what readelf to use)
2255 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2256 # Single tree build which includes binutils.
2257 AC_MSG_RESULT(newly built readelf)
2258 elif test x$gcc_cv_readelf = x; then
2259 AC_MSG_RESULT(not found)
2261 AC_MSG_RESULT($gcc_cv_readelf)
2264 # Figure out what assembler alignment features are present.
2265 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2269 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2270 [Define if your assembler supports .balign and .p2align.])])
2272 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2275 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2276 [Define if your assembler supports specifying the maximum number
2277 of bytes to skip when using the GAS .p2align command.])])
2279 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2282 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2283 [Define if your assembler supports .literal16.])])
2285 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2287 [conftest_label1: .word 0
2289 conftest_label2: .word 0
2291 [if test x$gcc_cv_nm != x; then
2292 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2293 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2294 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2296 else gcc_cv_as_subsection_m1=yes
2298 rm -f conftest.nm1 conftest.nm2
2300 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2301 [Define if your assembler supports .subsection and .subsection -1 starts
2302 emitting at the beginning of your section.])])
2304 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2307 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2309 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2311 [ .weakref foobar, barfnot],,
2312 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2314 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2317 .NSUBSPA $CODE$,COMDAT],,
2318 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2320 # .hidden needs to be supported in both the assembler and the linker,
2321 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2322 # This is irritatingly difficult to feature test for; we have to check the
2323 # date string after the version number. If we've got an in-tree
2324 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2326 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2327 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2333 # Darwin as has some visibility support, though with a different syntax.
2334 gcc_cv_as_hidden=yes
2338 # gnu_indirect_function type is an extension proposed at
2339 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2340 # selection of function implementation
2341 AC_ARG_ENABLE(gnu-indirect-function,
2342 [AS_HELP_STRING([--enable-gnu-indirect-function],
2343 [enable the use of the @gnu_indirect_function to glibc systems])],
2344 [case $enable_gnu_indirect_function in
2346 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2347 Valid choices are 'yes' and 'no'.]) ;;
2349 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2351 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2352 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2353 [Define if your system supports gnu indirect functions.])
2357 if test $in_tree_ld != yes ; then
2358 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2359 if echo "$ld_ver" | grep GNU > /dev/null; then
2360 if test x"$ld_is_gold" = xyes; then
2361 # GNU gold --version looks like this:
2363 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2365 # We extract the binutils version which is more familiar and specific
2366 # than the gold version.
2367 ld_vers=`echo $ld_ver | sed -n \
2368 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2370 # GNU ld --version looks like this:
2372 # GNU ld (GNU Binutils) 2.21.51.20110225
2373 ld_vers=`echo $ld_ver | sed -n \
2374 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2376 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'`
2377 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2378 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2379 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2383 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2386 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2387 # /usr/ccs/bin/ld has been configured.
2388 ld_ver=`$gcc_cv_ld -V 2>&1`
2389 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2390 ld_vers=`echo $ld_ver | sed -n \
2391 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2392 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2393 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2401 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2402 [[if test $in_tree_ld = yes ; then
2404 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 \
2405 && test $in_tree_ld_is_elf = yes; then
2406 gcc_cv_ld_hidden=yes
2409 gcc_cv_ld_hidden=yes
2410 if test x"$ld_is_gold" = xyes; then
2412 elif echo "$ld_ver" | grep GNU > /dev/null; then
2414 mmix-knuth-mmixware)
2415 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2419 if test 0"$ld_date" -lt 20020404; then
2420 if test -n "$ld_date"; then
2421 # If there was date string, but was earlier than 2002-04-04, fail
2423 elif test -z "$ld_vers"; then
2424 # If there was no date string nor ld version number, something is wrong
2427 test -z "$ld_vers_patch" && ld_vers_patch=0
2428 if test "$ld_vers_major" -lt 2; then
2430 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2431 gcc_cv_ld_hidden="no"
2432 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2440 # Darwin ld has some visibility support.
2441 gcc_cv_ld_hidden=yes
2443 hppa64*-*-hpux* | ia64*-*-hpux*)
2444 gcc_cv_ld_hidden=yes
2446 *-*-solaris2.1[0-9]*)
2447 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2448 # .symbolic was only added in Solaris 9 12/02.
2449 gcc_cv_ld_hidden=yes
2457 libgcc_visibility=no
2458 AC_SUBST(libgcc_visibility)
2459 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2460 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2461 libgcc_visibility=yes
2462 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2463 [Define if your assembler and linker support .hidden.])
2466 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2467 gcc_cv_ld_ro_rw_mix=unknown
2468 if test $in_tree_ld = yes ; then
2469 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 \
2470 && test $in_tree_ld_is_elf = yes; then
2471 gcc_cv_ld_ro_rw_mix=read-write
2473 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2474 echo '.section myfoosect, "a"' > conftest1.s
2475 echo '.section myfoosect, "aw"' > conftest2.s
2476 echo '.byte 1' >> conftest2.s
2477 echo '.section myfoosect, "a"' > conftest3.s
2478 echo '.byte 0' >> conftest3.s
2479 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2480 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2481 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2482 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2483 conftest2.o conftest3.o > /dev/null 2>&1; then
2484 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2485 | sed -e '/myfoosect/!d' -e N`
2486 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2487 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2488 gcc_cv_ld_ro_rw_mix=read-only
2490 gcc_cv_ld_ro_rw_mix=read-write
2495 rm -f conftest.* conftest[123].*
2498 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2499 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2500 [Define if your linker links a mix of read-only
2501 and read-write sections into a read-write section.])
2503 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2505 gcc_AC_INITFINI_ARRAY
2507 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2508 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2516 [[# GAS versions before 2.11 do not support uleb128,
2517 # despite appearing to.
2518 # ??? There exists an elf-specific test that will crash
2519 # the assembler. Perhaps it's better to figure out whether
2520 # arbitrary sections are supported and try the test.
2521 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2522 if echo "$as_ver" | grep GNU > /dev/null; then
2523 as_vers=`echo $as_ver | sed -n \
2524 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2525 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2526 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2527 if test $as_major -eq 2 && test $as_minor -lt 11
2529 else gcc_cv_as_leb128=yes
2532 [AC_DEFINE(HAVE_AS_LEB128, 1,
2533 [Define if your assembler supports .sleb128 and .uleb128.])])
2535 # Check if we have assembler support for unwind directives.
2536 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2543 .cfi_escape 1, 2, 3, 4, 5
2547 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2548 # read-only and read-write sections, we need to make sure that the
2549 # assembler used emits read-write .eh_frame sections.
2550 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2551 if test "x$gcc_cv_objdump" != x; then
2552 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2553 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2554 gcc_cv_as_cfi_directive=no
2557 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2558 # On Solaris/x86, make sure that GCC and assembler agree on using
2559 # read-only .eh_frame sections for 64-bit.
2560 if test x$gas = xyes; then
2561 as_ix86_64_opt="--64"
2563 as_ix86_64_opt="-xarch=amd64"
2565 if $gcc_cv_as $as_ix86_64_opt -o conftest.o conftest.s > /dev/null 2>&1 && \
2566 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2567 sed -e /.eh_frame/!d -e N | \
2568 grep READONLY > /dev/null; then
2569 gcc_cv_as_cfi_directive=yes
2571 gcc_cv_as_cfi_directive=no
2575 gcc_cv_as_cfi_directive=yes
2580 # no objdump, err on the side of caution
2581 gcc_cv_as_cfi_directive=no
2584 gcc_cv_as_cfi_directive=yes
2588 gcc_cv_as_cfi_directive=yes
2591 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2592 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2596 .cfi_adjust_cfa_offset 64
2598 .cfi_adjust_cfa_offset 128
2601 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2602 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2603 gcc_cv_as_cfi_advance_working=yes
2607 # no objdump, err on the side of caution
2608 gcc_cv_as_cfi_advance_working=no
2610 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2611 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2612 [`if test $gcc_cv_as_cfi_directive = yes \
2613 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2614 [Define 0/1 if your assembler supports CFI directives.])
2616 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2617 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2618 gcc_cv_as_cfi_personality_directive, ,,
2621 .cfi_personality 0, symbol
2623 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2624 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2625 then echo 1; else echo 0; fi`],
2626 [Define 0/1 if your assembler supports .cfi_personality.])
2628 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2629 gcc_cv_as_cfi_sections_directive, ,,
2631 .cfi_sections .debug_frame, .eh_frame
2635 win32 | pe | cygwin* | mingw32* | uwin*)
2636 # Need to check that we generated the correct relocation for the
2637 # .debug_frame section. This was fixed for binutils 2.21.
2638 gcc_cv_as_cfi_sections_directive=no
2639 if test "x$gcc_cv_objdump" != x; then
2640 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2641 grep secrel > /dev/null; then
2642 gcc_cv_as_cfi_sections_directive=yes
2647 gcc_cv_as_cfi_sections_directive=yes
2650 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2651 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2652 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2653 then echo 1; else echo 0; fi`],
2654 [Define 0/1 if your assembler supports .cfi_sections.])
2656 # GAS versions up to and including 2.11.0 may mis-optimize
2658 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2666 .section .eh_frame,"aw",@progbits
2668 .4byte .LECIE1-.LSCIE1
2682 .4byte .LEFDE1-.LASFDE1
2684 .4byte .LASFDE1-__FRAME_BEGIN__
2692 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2693 cat > conftest.lit <<EOF
2694 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2695 0010 01000000 12000000 18000000 00000000 ................
2696 0020 08000000 04080000 0044 .........D @&t@
2698 cat > conftest.big <<EOF
2699 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2700 0010 00000001 00000012 00000018 00000000 ................
2701 0020 00000008 04000000 0844 .........D @&t@
2703 # If the assembler didn't choke, and we can objdump,
2704 # and we got the correct data, then succeed.
2705 # The text in the here-document typically retains its unix-style line
2706 # endings, while the output of objdump will use host line endings.
2707 # Therefore, use diff -b for the comparisons.
2708 if test x$gcc_cv_objdump != x \
2709 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2710 | tail -3 > conftest.got \
2711 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2712 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2714 gcc_cv_as_eh_frame=yes
2715 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2716 gcc_cv_as_eh_frame=buggy
2718 # Uh oh, what do we do now?
2719 gcc_cv_as_eh_frame=no
2722 if test $gcc_cv_as_eh_frame = buggy; then
2723 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2724 [Define if your assembler mis-optimizes .eh_frame data.])
2727 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2728 [elf,2,12,0], [--fatal-warnings],
2729 [.section .rodata.str, "aMS", @progbits, 1])
2730 if test $gcc_cv_as_shf_merge = no; then
2731 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2732 [elf,2,12,0], [--fatal-warnings],
2733 [.section .rodata.str, "aMS", %progbits, 1])
2735 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2736 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2737 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2739 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2740 gcc_cv_as_comdat_group,
2741 [elf,2,16,0], [--fatal-warnings],
2742 [.section .text,"axG",@progbits,.foo,comdat])
2743 if test $gcc_cv_as_comdat_group = yes; then
2744 gcc_cv_as_comdat_group_percent=no
2745 gcc_cv_as_comdat_group_group=no
2747 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2748 gcc_cv_as_comdat_group_percent,
2749 [elf,2,16,0], [--fatal-warnings],
2750 [.section .text,"axG",%progbits,.foo,comdat])
2751 if test $gcc_cv_as_comdat_group_percent = yes; then
2752 gcc_cv_as_comdat_group_group=no
2754 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2755 gcc_cv_as_comdat_group_group=no
2758 # Sun as uses a completely different syntax.
2763 .group foo,".text%foo",#comdat
2764 .section ".text%foo", #alloc,#execinstr,#progbits
2769 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2771 .group foo,.text%foo,#comdat
2772 .section .text%foo, "ax", @progbits
2778 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2779 gcc_cv_as_comdat_group_group,
2785 if test x"$ld_is_gold" = xyes; then
2787 elif test $in_tree_ld = yes ; then
2789 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 \
2790 && test $in_tree_ld_is_elf = yes; then
2793 elif echo "$ld_ver" | grep GNU > /dev/null; then
2795 if test 0"$ld_date" -lt 20050308; then
2796 if test -n "$ld_date"; then
2797 # If there was date string, but was earlier than 2005-03-08, fail
2799 elif test "$ld_vers_major" -lt 2; then
2801 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2808 *-*-solaris2.1[1-9]*)
2810 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2811 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2814 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2815 # least ld version 1.2267.
2816 if test "$ld_vers_major" -gt 1; then
2818 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2820 elif test "$ld_vers_minor" -ge 2267; then
2825 # Assume linkers other than GNU ld don't support COMDAT group.
2831 # Allow overriding the automatic COMDAT group tests above.
2832 AC_ARG_ENABLE(comdat,
2833 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2834 [comdat_group="$enable_comdat"])
2835 if test $comdat_group = no; then
2836 gcc_cv_as_comdat_group=no
2837 gcc_cv_as_comdat_group_percent=no
2838 gcc_cv_as_comdat_group_group=no
2840 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2841 [`if test $gcc_cv_as_comdat_group = yes \
2842 || test $gcc_cv_as_comdat_group_percent = yes \
2843 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2844 [Define 0/1 if your assembler and linker support COMDAT groups.])
2846 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2847 gcc_cv_as_discriminator,
2851 .loc 1 1 0 discriminator 1],,
2852 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2853 [Define if your assembler supports the .loc discriminator sub-directive.])])
2855 # Thread-local storage - the check is heavily parameterized.
2864 .section ".tdata","awT",@progbits
2867 ldq $27,__tls_get_addr($29) !literal!1
2868 lda $16,foo($29) !tlsgd!1
2869 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2870 ldq $27,__tls_get_addr($29) !literal!2
2871 lda $16,foo($29) !tlsldm!2
2872 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2873 ldq $1,foo($29) !gotdtprel
2874 ldah $2,foo($29) !dtprelhi
2875 lda $3,foo($2) !dtprello
2876 lda $4,foo($29) !dtprel
2877 ldq $1,foo($29) !gottprel
2878 ldah $2,foo($29) !tprelhi
2879 lda $3,foo($2) !tprello
2880 lda $4,foo($29) !tprel'
2883 tls_as_opt=--fatal-warnings
2885 cris-*-*|crisv32-*-*)
2887 .section ".tdata","awT",@progbits
2894 tls_as_opt=--fatal-warnings
2898 .section ".tdata","awT",@progbits
2910 .section ".tdata","awT",@progbits
2914 addil LT%foo-$tls_gdidx$,gp
2915 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2918 addil LT%foo-$tls_ldidx$,gp
2920 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2921 addil LR%foo-$tls_dtpoff$,%ret0
2922 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2924 addil LT%foo-$tls_ieoff$,gp
2925 ldw RT%foo-$tls_ieoff$(%r1),%t2
2928 addil LR%foo-$tls_leoff$,%t1
2929 ldo RR%foo-$tls_leoff$(%r1),%t2'
2932 tls_as_opt=--fatal-warnings
2936 .section ".tdata","awT",%progbits
2947 i[34567]86-*-* | x86_64-*-*)
2949 i[34567]86-*-solaris2.* | x86_64-*-solaris2.1[0-9]*)
2956 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2958 .section .tdata,"awt",@progbits'
2963 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2964 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2968 .section ".tdata","awT",@progbits'
2972 tls_as_opt="--fatal-warnings"
2976 conftest_s="$conftest_s
2980 leal foo@tlsgd(,%ebx,1), %eax
2981 leal foo@tlsldm(%ebx), %eax
2982 leal foo@dtpoff(%eax), %edx
2983 movl foo@gottpoff(%ebx), %eax
2984 subl foo@gottpoff(%ebx), %eax
2985 addl foo@gotntpoff(%ebx), %eax
2986 movl foo@indntpoff, %eax
2987 movl \$foo@tpoff, %eax
2988 subl \$foo@tpoff, %eax
2989 leal foo@ntpoff(%ecx), %eax"
2992 if test x$on_solaris = xyes; then
2994 yes) tls_as_opt="$tls_as_opt --64" ;;
2995 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
2998 conftest_s="$conftest_s
3002 leaq foo@tlsgd(%rip), %rdi
3003 leaq foo@tlsld(%rip), %rdi
3004 leaq foo@dtpoff(%rax), %rdx
3005 movq foo@gottpoff(%rip), %rax
3006 movq \$foo@tpoff, %rax"
3012 .section ".tdata","awT",@progbits
3015 addl r16 = @ltoff(@dtpmod(foo#)), gp
3016 addl r17 = @ltoff(@dtprel(foo#)), gp
3017 addl r18 = @ltoff(@tprel(foo#)), gp
3018 addl r19 = @dtprel(foo#), gp
3019 adds r21 = @dtprel(foo#), r13
3020 movl r23 = @dtprel(foo#)
3021 addl r20 = @tprel(foo#), gp
3022 adds r22 = @tprel(foo#), r13
3023 movl r24 = @tprel(foo#)'
3026 tls_as_opt=--fatal-warnings
3030 .section .tdata,"awT",@progbits
3034 addik r5,r20,x@TLSGD
3035 addik r5,r20,x@TLSLDM'
3038 tls_as_opt='--fatal-warnings'
3042 .section .tdata,"awT",@progbits
3046 addiu $4, $28, %tlsgd(x)
3047 addiu $4, $28, %tlsldm(x)
3048 lui $4, %dtprel_hi(x)
3049 addiu $4, $4, %dtprel_lo(x)
3050 lw $4, %gottprel(x)($28)
3051 lui $4, %tprel_hi(x)
3052 addiu $4, $4, %tprel_lo(x)'
3055 tls_as_opt='-32 --fatal-warnings'
3059 .section .tdata,"awT",@progbits
3064 move.l x@TLSGD(%a5),%a0
3065 move.l x@TLSLDM(%a5),%a0
3066 move.l x@TLSLDO(%a5),%a0
3067 move.l x@TLSIE(%a5),%a0
3068 move.l x@TLSLE(%a5),%a0'
3071 tls_as_opt='--fatal-warnings'
3075 .section ".tdata","awT",@progbits'
3078 tls_as_opt="--fatal-warnings"
3082 .section ".tdata","awT",%progbits
3086 add x0, x0, #:tlsgd_lo12:x
3091 tls_as_opt='--fatal-warnings'
3095 .extern __get_tpointer
3113 .section ".tdata","awT",@progbits
3121 addi 3,2,ld0@got@tlsgd
3127 addi 3,2,x1@got@tlsld
3133 addis 9,3,x2@dtprel@ha
3134 addi 9,9,x2@dtprel@l
3137 ld 9,x3@got@dtprel(2)
3143 tls_as_opt="-a64 --fatal-warnings"
3147 .section ".tdata","awT",@progbits
3155 addi 3,31,ld0@got@tlsgd
3157 addi 3,31,x1@got@tlsld
3160 addis 9,3,x2@dtprel@ha
3161 addi 9,9,x2@dtprel@l
3162 lwz 9,x3@got@tprel(31)
3165 addis 9,2,x2@tprel@ha
3166 addi 9,9,x2@tprel@l'
3169 tls_as_opt="-a32 --fatal-warnings"
3173 .section ".tdata","awT",@progbits
3182 l %r1,foo@GOTNTPOFF(%r12)
3183 l %r1,0(%r1):tls_load:foo
3184 bas %r14,0(%r1,%r13):tls_gdcall:foo
3185 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3188 tls_as_opt="-m31 --fatal-warnings"
3192 .section ".tdata","awT",@progbits
3200 lg %r1,foo@GOTNTPOFF(%r12)
3201 larl %r1,foo@INDNTPOFF
3202 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3203 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3206 tls_as_opt="-m64 -Aesame --fatal-warnings"
3208 sh-*-* | sh[34]-*-*)
3210 .section ".tdata","awT",@progbits
3220 tls_as_opt=--fatal-warnings
3224 sparc*-sun-solaris2.*)
3231 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3233 .section ".tdata",#alloc,#write,#tls'
3238 .section ".tdata","awT",@progbits'
3241 tls_as_opt="-32 --fatal-warnings"
3243 conftest_s="$conftest_s
3246 sethi %tgd_hi22(foo), %o0
3247 add %o0, %tgd_lo10(foo), %o1
3248 add %l7, %o1, %o0, %tgd_add(foo)
3249 call __tls_get_addr, %tgd_call(foo)
3250 sethi %tldm_hi22(foo), %l1
3251 add %l1, %tldm_lo10(foo), %l2
3252 add %l7, %l2, %o0, %tldm_add(foo)
3253 call __tls_get_addr, %tldm_call(foo)
3254 sethi %tldo_hix22(foo), %l3
3255 xor %l3, %tldo_lox10(foo), %l4
3256 add %o0, %l4, %l5, %tldo_add(foo)
3257 sethi %tie_hi22(foo), %o3
3258 add %o3, %tie_lo10(foo), %o3
3259 ld [%l7 + %o3], %o2, %tie_ld(foo)
3260 add %g7, %o2, %o4, %tie_add(foo)
3261 sethi %tle_hix22(foo), %l1
3262 xor %l1, %tle_lox10(foo), %o5
3263 ld [%g7 + %o5], %o1"
3267 .section ".tdata","awT",@progbits
3270 addli r0, zero, tls_gd(foo)
3271 auli r0, zero, tls_gd_ha16(foo)
3272 addli r0, r0, tls_gd_lo16(foo)
3274 addli r0, zero, tls_ie(foo)
3275 auli r0, r0, tls_ie_ha16(foo)
3276 addli r0, r0, tls_ie_lo16(foo)'
3279 tls_as_opt="--fatal-warnings"
3283 .section ".tdata","awT",@progbits
3286 shl16insli r0, zero, hw0_last_tls_gd(foo)
3287 shl16insli r0, zero, hw1_last_tls_gd(foo)
3288 shl16insli r0, r0, hw0_tls_gd(foo)
3290 shl16insli r0, zero, hw1_last_tls_ie(foo)
3291 shl16insli r0, r0, hw0_tls_ie(foo)'
3294 tls_as_opt="--fatal-warnings"
3298 .section ".tdata","awT",@progbits
3301 movi a8, foo@TLSFUNC
3302 movi a10, foo@TLSARG
3303 callx8.tls a8, foo@TLSCALL'
3310 if test "x$enable_tls" = xno ; then
3311 : # TLS explicitly disabled.
3312 elif test "x$enable_tls" = xyes ; then
3313 set_have_as_tls=yes # TLS explicitly enabled.
3314 elif test -z "$tls_first_major"; then
3315 : # If we don't have a check, assume no support.
3317 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3318 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3319 [set_have_as_tls=yes])
3321 if test $set_have_as_tls = yes ; then
3322 AC_DEFINE(HAVE_AS_TLS, 1,
3323 [Define if your assembler and linker support thread-local storage.])
3326 # Target-specific assembler checks.
3328 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3329 gcc_cv_ld_static_dynamic=no
3330 gcc_cv_ld_static_option='-Bstatic'
3331 gcc_cv_ld_dynamic_option='-Bdynamic'
3332 if test $in_tree_ld = yes ; then
3333 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
3334 gcc_cv_ld_static_dynamic=yes
3336 elif test x$gcc_cv_ld != x; then
3337 # Check if linker supports -Bstatic/-Bdynamic option
3338 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3339 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3340 gcc_cv_ld_static_dynamic=yes
3343 # AIX ld uses -b flags
3344 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3345 gcc_cv_ld_static_dynamic=yes
3346 gcc_cv_ld_static_option="-bstatic"
3347 gcc_cv_ld_dynamic_option="-bdynamic"
3349 # HP-UX ld uses -a flags to select between shared and archive.
3351 if test x"$gnu_ld" = xno; then
3352 gcc_cv_ld_static_dynamic=yes
3353 gcc_cv_ld_static_option="-aarchive_shared"
3354 gcc_cv_ld_dynamic_option="-adefault"
3357 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3359 gcc_cv_ld_static_dynamic=yes
3364 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3365 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3366 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3367 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3368 [Define to the linker option to disable use of shared objects.])
3369 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3370 [Define to the linker option to enable use of shared objects.])
3372 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3374 if test x"$demangler_in_ld" = xyes; then
3375 AC_MSG_CHECKING(linker --demangle support)
3376 gcc_cv_ld_demangle=no
3377 if test $in_tree_ld = yes; then
3378 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 \
3379 gcc_cv_ld_demangle=yes
3381 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3382 # Check if the GNU linker supports --demangle option
3383 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3384 gcc_cv_ld_demangle=yes
3387 if test x"$gcc_cv_ld_demangle" = xyes; then
3388 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3389 [Define if your linker supports --demangle option.])
3391 AC_MSG_RESULT($gcc_cv_ld_demangle)
3394 AC_MSG_CHECKING(linker plugin support)
3396 if test -f liblto_plugin.la; then
3397 save_ld_ver="$ld_ver"
3398 save_ld_vers_major="$ld_vers_major"
3399 save_ld_vers_minor="$ld_vers_minor"
3400 save_ld_is_gold="$ld_is_gold"
3404 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3406 # FIXME: ld_is_gold?
3407 ld_vers_major="$gcc_cv_gld_major_version"
3408 ld_vers_minor="$gcc_cv_gld_minor_version"
3410 # Determine plugin linker version.
3411 # FIXME: Partial duplicate from above, generalize.
3413 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3414 if echo "$ld_ver" | grep GNU > /dev/null; then
3415 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3417 ld_vers=`echo $ld_ver | sed -n \
3418 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3420 ld_vers=`echo $ld_ver | sed -n \
3421 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3423 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3424 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3429 # Determine plugin support.
3430 if echo "$ld_ver" | grep GNU > /dev/null; then
3431 # Require GNU ld or gold 2.21+ for plugin support by default.
3432 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3434 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3435 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3440 ld_ver="$save_ld_ver"
3441 ld_vers_major="$save_ld_vers_major"
3442 ld_vers_minor="$save_ld_vers_minor"
3443 ld_is_gold="$save_ld_is_gold"
3445 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3446 [Define to the level of your linker's plugin support.])
3447 AC_MSG_RESULT($gcc_cv_lto_plugin)
3451 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3452 [-mabi=lp64], [.text],,,)
3453 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3454 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3455 [Define if your assembler supports the -mabi option.])
3457 if test x$with_abi = xilp32; then
3458 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3459 Upgrade the Assembler.])
3461 if test x"$with_multilib_list" = xdefault; then
3462 TM_MULTILIB_CONFIG=lp64
3464 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3465 for aarch64_multilib in ${aarch64_multilibs}; do
3466 case ${aarch64_multilib} in
3468 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3469 Upgrade the Assembler.])
3479 # All TARGET_ABI_OSF targets.
3480 alpha*-*-linux* | alpha*-*-*bsd*)
3481 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3482 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3485 extbl $3, $2, $3 !lituse_bytoff!1
3486 ldq $2, a($29) !literal!1
3487 ldq $4, b($29) !literal!2
3488 ldq_u $3, 0($2) !lituse_base!1
3489 ldq $27, f($29) !literal!5
3490 jsr $26, ($27), f !lituse_jsr!5
3491 ldah $29, 0($26) !gpdisp!3
3492 lda $0, c($29) !gprel
3493 ldah $1, d($29) !gprelhigh
3494 lda $1, d($1) !gprellow
3495 lda $29, 0($29) !gpdisp!3],,
3496 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3497 [Define if your assembler supports explicit relocations.])])
3498 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3499 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3502 ldq $27, a($29) !literal!1
3503 jsr $26, ($27), a !lituse_jsrdirect!1],,
3504 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3505 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3509 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3510 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3511 [-no-mul-bug-abort], [.text],,
3512 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3513 [Define if your assembler supports the -no-mul-bug-abort option.])])
3517 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3518 [.register %g2, #scratch],,
3519 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3520 [Define if your assembler supports .register.])])
3522 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3523 [.section "nobits",#alloc,#write,#nobits
3524 .section "progbits",#alloc,#write,#progbits])
3525 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3526 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3527 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3529 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3531 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3532 [Define if your assembler supports -relax option.])])
3534 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3535 gcc_cv_as_sparc_gotdata_op,,
3542 sethi %gdop_hix22(foo), %g1
3543 xor %g1, %gdop_lox10(foo), %g1
3544 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3545 [if test x$gcc_cv_ld != x \
3546 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3547 if test x$gcc_cv_objdump != x; then
3548 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3549 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3550 gcc_cv_as_sparc_gotdata_op=no
3552 gcc_cv_as_sparc_gotdata_op=yes
3557 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3558 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3560 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3561 gcc_cv_as_sparc_ua_pcrel,,
3569 .uaword %r_disp32(foo)],
3570 [if test x$gcc_cv_ld != x \
3571 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3572 gcc_cv_as_sparc_ua_pcrel=yes
3575 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3576 [Define if your assembler and linker support unaligned PC relative relocs.])
3578 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3579 gcc_cv_as_sparc_ua_pcrel_hidden,,
3584 .uaword %r_disp32(foo)
3585 .byte 0x32, 0x33, 0x34
3590 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3591 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3592 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3593 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3594 if $gcc_cv_objdump -R conftest 2> /dev/null \
3595 | grep 'DISP32' > /dev/null 2>&1; then
3598 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3602 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3603 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3604 ]) # unaligned pcrel relocs
3606 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3607 gcc_cv_as_sparc_offsetable_lo10,,
3610 or %g1, %lo(ab) + 12, %g1
3611 or %g1, %lo(ab + 12), %g1],
3612 [if test x$gcc_cv_objdump != x \
3613 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3614 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3615 gcc_cv_as_sparc_offsetable_lo10=yes
3617 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3618 [Define if your assembler supports offsetable %lo().])])
3620 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3621 gcc_cv_as_sparc_fmaf,,
3624 .register %g2, #scratch
3625 .register %g3, #scratch
3627 fmaddd %f0, %f2, %f4, %f6
3628 addxccc %g1, %g2, %g3
3629 fsrl32 %f2, %f4, %f8
3630 fnaddd %f10, %f12, %f14],,
3631 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3632 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3634 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3635 gcc_cv_as_sparc_sparc4,,
3638 .register %g2, #scratch
3639 .register %g3, #scratch
3642 1: cwbneg %g2, %g3, 1f
3645 aes_kexpand0 %f4, %f6, %f8
3646 des_round %f38, %f40, %f42, %f44
3647 camellia_f %f54, %f56, %f58, %f60
3648 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3649 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3650 [Define if your assembler supports SPARC4 instructions.])])
3652 gcc_GAS_CHECK_FEATURE([LEON instructions],
3653 gcc_cv_as_sparc_leon,,
3656 .register %g2, #scratch
3657 .register %g3, #scratch
3661 casa [[%g2]] 0xb, %g3, %g1],,
3662 [AC_DEFINE(HAVE_AS_LEON, 1,
3663 [Define if your assembler supports LEON instructions.])])
3667 i[34567]86-*-* | x86_64-*-*)
3671 # Full C++ conformance when using a shared libstdc++-v3 requires some
3672 # support from the Cygwin DLL, which in more recent versions exports
3673 # wrappers to aid in interposing and redirecting operators new, delete,
3674 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3675 # are configuring for a version of Cygwin that exports the wrappers.
3676 if test x$host = x$target && test x$host_cpu = xi686; then
3677 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3679 # Can't check presence of libc functions during cross-compile, so
3680 # we just have to assume we're building for an up-to-date target.
3681 gcc_ac_cygwin_dll_wrappers=yes
3683 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3684 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3685 [Define if you want to generate code by default that assumes that the
3686 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3689 cygwin* | pe | mingw32* | interix*)
3690 # Recent binutils allows the three-operand form of ".comm" on PE. This
3691 # definition is used unconditionally to initialise the default state of
3692 # the target option variable that governs usage of the feature.
3693 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3694 [2,19,52],,[.comm foo,1,32])
3695 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3696 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3697 [Define if your assembler supports specifying the alignment
3698 of objects allocated using the GAS .comm command.])
3699 # Used for DWARF 2 in PE
3700 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3701 gcc_cv_as_ix86_pe_secrel32,
3707 [if test x$gcc_cv_ld != x \
3708 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3709 gcc_cv_as_ix86_pe_secrel32=yes
3712 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3713 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3714 # Test if the assembler supports the extended form of the .section
3715 # directive that specifies section alignment. LTO support uses this,
3716 # but normally only after installation, so we warn but don't fail the
3717 # configure if LTO is enabled but the assembler does not support it.
3718 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3719 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3720 if test x$gcc_cv_as_section_has_align != xyes; then
3721 case ",$enable_languages," in
3723 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3727 # Test if the assembler supports the section flag 'e' for specifying
3728 # an excluded section.
3729 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3733 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3734 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3735 [Define if your assembler supports specifying the section flag e.])
3739 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3740 gcc_cv_as_ix86_filds,,,
3741 [filds mem; fists mem],,
3742 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3743 [Define if your assembler uses filds and fists mnemonics.])])
3745 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3746 gcc_cv_as_ix86_fildq,,,
3747 [fildq mem; fistpq mem],,
3748 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3749 [Define if your assembler uses fildq and fistq mnemonics.])])
3751 gcc_GAS_CHECK_FEATURE([cmov syntax],
3752 gcc_cv_as_ix86_cmov_sun_syntax,,,
3753 [cmovl.l %edx, %eax],,
3754 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3755 [Define if your assembler supports the Sun syntax for cmov.])])
3757 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3758 gcc_cv_as_ix86_ffreep,,,
3760 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3761 [Define if your assembler supports the ffreep mnemonic.])])
3763 gcc_GAS_CHECK_FEATURE([.quad directive],
3764 gcc_cv_as_ix86_quad,,,
3766 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3767 [Define if your assembler supports the .quad directive.])])
3769 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3770 gcc_cv_as_ix86_sahf,,,
3773 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3774 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3776 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3777 gcc_cv_as_ix86_interunit_movq,,,
3781 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3782 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3783 [Define if your assembler supports interunit movq mnemonic.])
3785 gcc_GAS_CHECK_FEATURE([hle prefixes],
3786 gcc_cv_as_ix86_hle,,,
3787 [lock xacquire cmpxchg %esi, (%ecx)],,
3788 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3789 [Define if your assembler supports HLE prefixes.])])
3791 gcc_GAS_CHECK_FEATURE([swap suffix],
3792 gcc_cv_as_ix86_swap,,,
3793 [movl.s %esp, %ebp],,
3794 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3795 [Define if your assembler supports the swap suffix.])])
3797 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3798 gcc_cv_as_ix86_diff_sect_delta,,,
3806 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3807 [Define if your assembler supports the subtraction of symbols in different sections.])])
3809 # These two are used unconditionally by i386.[ch]; it is to be defined
3810 # to 1 if the feature is present, 0 otherwise.
3811 as_ix86_gotoff_in_data_opt=
3812 if test x$gas = xyes; then
3813 as_ix86_gotoff_in_data_opt="--32"
3815 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3816 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3817 [$as_ix86_gotoff_in_data_opt],
3823 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3824 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3825 [Define true if the assembler supports '.long foo@GOTOFF'.])
3827 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3828 gcc_cv_as_ix86_rep_lock_prefix,,,
3834 lock addl %edi, (%eax,%esi)
3835 lock orl $0, (%esp)],,
3836 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3837 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3839 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3840 gcc_cv_as_ix86_ud2,,,
3842 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3843 [Define if your assembler supports the 'ud2' mnemonic.])])
3845 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3846 gcc_cv_as_ix86_tlsgdplt,,,
3847 [call tls_gd@tlsgdplt],
3848 [if test x$gcc_cv_ld != x \
3849 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3850 gcc_cv_as_ix86_tlsgdplt=yes
3853 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3854 [Define if your assembler and linker support @tlsgdplt.])])
3857 .section .tdata,"aw'$tls_section_flag'",@progbits
3859 .section .text,"ax",@progbits
3860 call tls_ld@tlsldmplt'
3861 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3862 gcc_cv_as_ix86_tlsldmplt,,,
3864 [if test x$gcc_cv_ld != x \
3865 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3866 gcc_cv_as_ix86_tlsldmplt=yes
3869 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3870 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3871 [Define to 1 if your assembler and linker support @tlsldmplt.])
3873 # Enforce 32-bit output with gas and gld.
3874 if test x$gas = xyes; then
3875 as_ix86_tls_ldm_opt="--32"
3877 if echo "$ld_ver" | grep GNU > /dev/null; then
3878 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3879 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3881 ld_ix86_tls_ldm_opt="-melf_i386"
3885 .section .text,"ax",@progbits
3887 .type _start, @function
3889 leal value@tlsldm(%ebx), %eax
3890 call ___tls_get_addr@plt
3892 .section .tdata,"aw'$tls_section_flag'",@progbits
3893 .type value, @object
3895 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3896 gcc_cv_as_ix86_tlsldm,,
3897 [$as_ix86_tls_ldm_opt],
3899 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3900 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3901 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3902 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3903 gcc_cv_as_ix86_tlsldm=yes
3907 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3908 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3909 [Define to 1 if your assembler and linker support @tlsldm.])
3914 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3915 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3917 addl r15 = @ltoffx(x#), gp
3919 ld8.mov r16 = [[r15]], x#],,
3920 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3921 [Define if your assembler supports ltoffx and ldxmov relocations.])])
3927 *-*-aix*) conftest_s=' .machine "pwr5"
3931 gcc_GAS_CHECK_FEATURE([.machine directive support],
3932 gcc_cv_as_machine_directive,,,
3933 [ .machine ppc7400])
3934 if test x$gcc_cv_as_machine_directive != xyes; then
3935 echo "*** This target requires an assembler supporting \".machine\"" >&2
3936 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3937 test x$build = x$target && exit 1
3941 *) conftest_s=' .machine power4
3946 gcc_GAS_CHECK_FEATURE([mfcr field support],
3947 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3949 [AC_DEFINE(HAVE_AS_MFCRF, 1,
3950 [Define if your assembler supports mfcr field.])])
3953 *-*-aix*) conftest_s=' .machine "pwr5"
3956 *) conftest_s=' .machine power5
3961 gcc_GAS_CHECK_FEATURE([popcntb support],
3962 gcc_cv_as_powerpc_popcntb, [2,17,0],,
3964 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3965 [Define if your assembler supports popcntb field.])])
3968 *-*-aix*) conftest_s=' .machine "pwr5x"
3971 *) conftest_s=' .machine power5
3976 gcc_GAS_CHECK_FEATURE([fp round support],
3977 gcc_cv_as_powerpc_fprnd, [2,17,0],,
3979 [AC_DEFINE(HAVE_AS_FPRND, 1,
3980 [Define if your assembler supports fprnd.])])
3983 *-*-aix*) conftest_s=' .machine "pwr6"
3986 *) conftest_s=' .machine power6
3991 gcc_GAS_CHECK_FEATURE([move fp gpr support],
3992 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
3994 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3995 [Define if your assembler supports mffgpr and mftgpr.])])
3998 *-*-aix*) conftest_s=' .csect .text[[PR]]
4000 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4004 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4005 *) conftest_s=' .text
4007 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4010 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4011 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4013 [AC_DEFINE(HAVE_AS_REL16, 1,
4014 [Define if your assembler supports R_PPC_REL16 relocs.])])
4017 *-*-aix*) conftest_s=' .machine "pwr6"
4020 *) conftest_s=' .machine power6
4025 gcc_GAS_CHECK_FEATURE([compare bytes support],
4026 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4028 [AC_DEFINE(HAVE_AS_CMPB, 1,
4029 [Define if your assembler supports cmpb.])])
4032 *-*-aix*) conftest_s=' .machine "pwr6"
4035 *) conftest_s=' .machine power6
4040 gcc_GAS_CHECK_FEATURE([decimal float support],
4041 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4043 [AC_DEFINE(HAVE_AS_DFP, 1,
4044 [Define if your assembler supports DFP instructions.])])
4047 *-*-aix*) conftest_s=' .machine "pwr7"
4050 *) conftest_s=' .machine power7
4055 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4056 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4058 [AC_DEFINE(HAVE_AS_VSX, 1,
4059 [Define if your assembler supports VSX instructions.])])
4062 *-*-aix*) conftest_s=' .machine "pwr7"
4065 *) conftest_s=' .machine power7
4070 gcc_GAS_CHECK_FEATURE([popcntd support],
4071 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4073 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4074 [Define if your assembler supports POPCNTD instructions.])])
4077 *-*-aix*) conftest_s=' .machine "pwr8"
4078 .csect .text[[PR]]';;
4079 *) conftest_s=' .machine power8
4083 gcc_GAS_CHECK_FEATURE([power8 support],
4084 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4086 [AC_DEFINE(HAVE_AS_POWER8, 1,
4087 [Define if your assembler supports POWER8 instructions.])])
4090 *-*-aix*) conftest_s=' .csect .text[[PR]]
4092 *) conftest_s=' .text
4096 gcc_GAS_CHECK_FEATURE([lwsync support],
4097 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4099 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4100 [Define if your assembler supports LWSYNC instructions.])])
4103 *-*-aix*) conftest_s=' .machine "476"
4106 *) conftest_s=' .machine "476"
4111 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4112 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4114 [AC_DEFINE(HAVE_AS_DCI, 1,
4115 [Define if your assembler supports the DCI/ICI instructions.])])
4117 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4118 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4119 [.gnu_attribute 4,1],,
4120 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4121 [Define if your assembler supports .gnu_attribute.])])
4123 gcc_GAS_CHECK_FEATURE([tls marker support],
4124 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4125 [ bl __tls_get_addr(x@tlsgd)],,
4126 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4127 [Define if your assembler supports arg info for __tls_get_addr.])])
4131 gcc_GAS_CHECK_FEATURE([.ref support],
4132 gcc_cv_as_aix_ref, [2,21,0],,
4133 [ .csect stuff[[rw]]
4139 [AC_DEFINE(HAVE_AS_REF, 1,
4140 [Define if your assembler supports .ref])])
4146 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4147 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4148 [ lw $4,%gp_rel(foo)($4)],,
4149 [if test x$target_cpu_default = x
4150 then target_cpu_default=MASK_EXPLICIT_RELOCS
4151 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4153 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4154 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4155 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4156 [Define if the assembler understands -mno-shared.])])
4158 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4159 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4160 [.gnu_attribute 4,1],,
4161 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4162 [Define if your assembler supports .gnu_attribute.])])
4164 gcc_GAS_CHECK_FEATURE([.micromips support],
4165 gcc_cv_as_micromips_support,,[--fatal-warnings],
4167 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4168 [Define if your assembler supports the .set micromips directive])])
4170 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4171 gcc_cv_as_mips_dtprelword, [2,18,0],,
4172 [.section .tdata,"awT",@progbits
4176 .dtprelword x+0x8000],,
4177 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4178 [Define if your assembler supports .dtprelword.])])
4180 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4181 gcc_cv_as_mips_dspr1_mult,,,
4191 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4192 [Define if your assembler supports DSPR1 mult.])])
4194 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4195 gcc_cv_as_ld_jalr_reloc=no
4196 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4197 if test $in_tree_ld = yes ; then
4198 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 \
4199 && test $in_tree_ld_is_elf = yes; then
4200 gcc_cv_as_ld_jalr_reloc=yes
4202 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4203 echo ' .ent x' > conftest.s
4204 echo 'x: lw $2,%got_disp(y)($3)' >> conftest.s
4205 echo ' lw $25,%call16(y)($28)' >> conftest.s
4206 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4207 echo '1: jalr $25' >> conftest.s
4208 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4209 echo '1: jalr $25' >> conftest.s
4210 echo ' .end x' >> conftest.s
4211 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4212 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4213 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4214 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4215 gcc_cv_as_ld_jalr_reloc=yes
4221 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4222 if test x$target_cpu_default = x; then
4223 target_cpu_default=MASK_RELAX_PIC_CALLS
4225 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4228 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4230 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4231 [gcc_cv_ld_mips_personality_relaxation],
4232 [gcc_cv_ld_mips_personality_relaxation=no
4233 if test $in_tree_ld = yes ; then
4234 if test "$gcc_cv_gld_major_version" -eq 2 \
4235 -a "$gcc_cv_gld_minor_version" -ge 21 \
4236 -o "$gcc_cv_gld_major_version" -gt 2; then
4237 gcc_cv_ld_mips_personality_relaxation=yes
4239 elif test x$gcc_cv_as != x \
4240 -a x$gcc_cv_ld != x \
4241 -a x$gcc_cv_readelf != x ; then
4242 cat > conftest.s <<EOF
4244 .cfi_personality 0x80,indirect_ptr
4251 .section .data,"aw",@progbits
4255 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4256 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4257 if $gcc_cv_readelf -d conftest 2>&1 \
4258 | grep TEXTREL > /dev/null 2>&1; then
4260 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4261 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4264 gcc_cv_ld_mips_personality_relaxation=yes
4268 rm -f conftest.s conftest.o conftest])
4269 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4270 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4271 [Define if your linker can relax absolute .eh_frame personality
4272 pointers into PC-relative form.])
4275 gcc_GAS_CHECK_FEATURE([-mnan= support],
4276 gcc_cv_as_mips_nan,,
4278 [AC_DEFINE(HAVE_AS_NAN, 1,
4279 [Define if the assembler understands -mnan=.])])
4280 if test x$gcc_cv_as_mips_nan = xno \
4281 && test x$with_nan != x; then
4283 [Requesting --with-nan= requires assembler support for -mnan=])
4288 # Mips and HP-UX need the GNU assembler.
4289 # Linux on IA64 might be able to use the Intel assembler.
4292 mips*-*-* | *-*-hpux* )
4293 if test x$gas_flag = xyes \
4294 || test x"$host" != x"$build" \
4295 || test ! -x "$gcc_cv_as" \
4296 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4299 echo "*** This configuration requires the GNU assembler" >&2
4305 # ??? Not all targets support dwarf2 debug_line, even within a version
4306 # of gas. Moreover, we need to emit a valid instruction to trigger any
4307 # info to the output file. So, as supported targets are added to gas 2.11,
4308 # add some instruction here to (also) show we expect this might work.
4309 # ??? Once 2.11 is released, probably need to add first known working
4310 # version to the per-target configury.
4312 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4313 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4314 | xstormy16 | xtensa)
4324 if test x"$insn" != x; then
4326 .file 1 \"conftest.s\"
4329 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4330 gcc_cv_as_dwarf2_debug_line,
4331 [elf,2,11,0],, [$conftest_s],
4332 [if test x$gcc_cv_objdump != x \
4333 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4334 | grep debug_line > /dev/null 2>&1; then
4335 gcc_cv_as_dwarf2_debug_line=yes
4338 # The .debug_line file table must be in the exact order that
4339 # we specified the files, since these indices are also used
4340 # by DW_AT_decl_file. Approximate this test by testing if
4341 # the assembler bitches if the same index is assigned twice.
4342 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4343 gcc_cv_as_dwarf2_file_buggy,,,
4347 if test $gcc_cv_as_dwarf2_debug_line = yes \
4348 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4349 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4350 [Define if your assembler supports dwarf2 .file/.loc directives,
4351 and preserves file table indices exactly as given.])
4354 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4355 gcc_cv_as_gdwarf2_flag,
4356 [elf,2,11,0], [--gdwarf2], [$insn],,
4357 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4358 [Define if your assembler supports the --gdwarf2 option.])])
4360 gcc_GAS_CHECK_FEATURE([--gstabs option],
4361 gcc_cv_as_gstabs_flag,
4362 [elf,2,11,0], [--gstabs], [$insn],,
4363 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4364 [Define if your assembler supports the --gstabs option.])])
4366 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4367 gcc_cv_as_debug_prefix_map_flag,
4368 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4369 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4370 [Define if your assembler supports the --debug-prefix-map option.])])
4373 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4376 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4377 [Define if your assembler supports .lcomm with an alignment field.])])
4379 if test x$with_sysroot = x && test x$host = x$target \
4380 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4381 && test "$prefix" != "NONE"; then
4382 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4383 [Define to PREFIX/include if cpp should also search that directory.])
4386 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4387 if test "x$with_headers" != x; then
4388 target_header_dir=$with_headers
4389 elif test "x$with_sysroot" = x; then
4390 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4391 elif test "x$with_build_sysroot" != "x"; then
4392 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4393 elif test "x$with_sysroot" = xyes; then
4394 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4396 target_header_dir="${with_sysroot}${native_system_header_dir}"
4399 target_header_dir=${native_system_header_dir}
4402 # Determine the version of glibc, if any, used on the target.
4403 AC_MSG_CHECKING([for target glibc version])
4404 AC_ARG_WITH([glibc-version],
4405 [AS_HELP_STRING([--with-glibc-version=M.N],
4406 [assume GCC used with glibc version M.N or later])], [
4407 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4408 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4409 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4411 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4413 glibc_version_major=0
4414 glibc_version_minor=0
4415 [if test -f $target_header_dir/features.h \
4416 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4417 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4418 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4419 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4421 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4423 AC_ARG_ENABLE(gnu-unique-object,
4424 [AS_HELP_STRING([--enable-gnu-unique-object],
4425 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4426 [case $enable_gnu_unique_object in
4428 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4429 Valid choices are 'yes' and 'no'.]) ;;
4431 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4433 [.type foo, '$target_type_format_char'gnu_unique_object],,
4434 # We need to unquote above to to use the definition from config.gcc.
4435 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4436 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4438 if test x$enable_gnu_unique_object = xyes; then
4439 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4440 [Define if your assembler supports @gnu_unique_object.])
4443 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4444 [gcc_cv_as_line_zero],
4445 [gcc_cv_as_line_zero=no
4446 if test $in_tree_gas = yes; then
4447 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4448 elif test "x$gcc_cv_as" != x; then
4449 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4450 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4451 test "x`cat conftest.out`" = x
4453 gcc_cv_as_line_zero=yes
4455 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4456 cat conftest.s >&AS_MESSAGE_LOG_FD
4457 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4458 cat conftest.out >&AS_MESSAGE_LOG_FD
4460 rm -f conftest.o conftest.s conftest.out
4462 if test "x$gcc_cv_as_line_zero" = xyes; then
4463 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4464 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4467 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4468 gcc_cv_ld_eh_frame_hdr=no
4469 if test $in_tree_ld = yes ; then
4470 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 \
4471 && test $in_tree_ld_is_elf = yes; then
4472 gcc_cv_ld_eh_frame_hdr=yes
4474 elif test x$gcc_cv_ld != x; then
4475 if echo "$ld_ver" | grep GNU > /dev/null; then
4476 # Check if linker supports --eh-frame-hdr option
4477 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4478 gcc_cv_ld_eh_frame_hdr=yes
4483 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4484 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4485 gcc_cv_ld_eh_frame_hdr=yes
4491 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4492 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4493 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4494 [Define if your linker supports .eh_frame_hdr.])
4496 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4498 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4499 gcc_cv_ld_eh_frame_ciev3=no
4500 if test $in_tree_ld = yes ; then
4501 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 \
4502 && test $in_tree_ld_is_elf = yes; then
4503 gcc_cv_ld_eh_frame_ciev3=yes
4505 elif test x$gcc_cv_ld != x; then
4506 if echo "$ld_ver" | grep GNU > /dev/null; then
4507 gcc_cv_ld_eh_frame_ciev3=yes
4508 if test 0"$ld_date" -lt 20040513; then
4509 if test -n "$ld_date"; then
4510 # If there was date string, but was earlier than 2004-05-13, fail
4511 gcc_cv_ld_eh_frame_ciev3=no
4512 elif test "$ld_vers_major" -lt 2; then
4513 gcc_cv_ld_eh_frame_ciev3=no
4514 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4515 gcc_cv_ld_eh_frame_ciev3=no
4521 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4522 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4523 gcc_cv_ld_eh_frame_ciev3=yes
4529 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4530 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4531 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4532 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4534 AC_MSG_CHECKING(linker position independent executable support)
4536 if test $in_tree_ld = yes ; then
4537 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 \
4538 && test $in_tree_ld_is_elf = yes; then
4541 elif test x$gcc_cv_ld != x; then
4542 # Check if linker supports -pie option
4543 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4547 if test x"$gcc_cv_ld_pie" = xyes; then
4548 AC_DEFINE(HAVE_LD_PIE, 1,
4549 [Define if your linker supports -pie option.])
4551 AC_MSG_RESULT($gcc_cv_ld_pie)
4553 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4554 gcc_cv_ld_eh_gc_sections=no
4555 if test $in_tree_ld = yes ; then
4556 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 \
4557 && test $in_tree_ld_is_elf = yes; then
4558 gcc_cv_ld_eh_gc_sections=yes
4560 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4561 cat > conftest.s <<EOF
4564 .type _start, @function
4567 .size _start, .-_start
4568 .section .text.foo,"ax",@progbits
4569 .type foo, @function
4573 .section .gcc_except_table.foo,"a",@progbits
4576 .section .eh_frame,"a",@progbits
4579 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4580 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4581 | grep "gc-sections option ignored" > /dev/null; then
4582 gcc_cv_ld_eh_gc_sections=no
4583 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4584 | grep gcc_except_table > /dev/null; then
4585 gcc_cv_ld_eh_gc_sections=yes
4586 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4587 if test x$gcc_cv_as_comdat_group != xyes; then
4588 gcc_cv_ld_eh_gc_sections=no
4589 cat > conftest.s <<EOF
4592 .type _start, @function
4595 .size _start, .-_start
4596 .section .gnu.linkonce.t.foo,"ax",@progbits
4597 .type foo, @function
4601 .section .gcc_except_table.foo,"a",@progbits
4604 .section .eh_frame,"a",@progbits
4607 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4608 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4609 | grep "gc-sections option ignored" > /dev/null; then
4610 gcc_cv_ld_eh_gc_sections=no
4611 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4612 | grep gcc_except_table > /dev/null; then
4613 gcc_cv_ld_eh_gc_sections=yes
4619 rm -f conftest.s conftest.o conftest
4623 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4624 gcc_cv_ld_eh_gc_sections=no
4627 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4628 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4629 [Define if your linker supports garbage collection of
4630 sections in presence of EH frames.])
4632 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4634 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4635 gcc_cv_ld_eh_gc_sections_bug=no
4636 if test $in_tree_ld = yes ; then
4637 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 \
4638 && test $in_tree_ld_is_elf = yes; then
4639 gcc_cv_ld_eh_gc_sections_bug=yes
4641 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
4642 gcc_cv_ld_eh_gc_sections_bug=yes
4643 cat > conftest.s <<EOF
4646 .type _start, @function
4649 .size _start, .-_start
4650 .section .text.startup.foo,"ax",@progbits
4651 .type foo, @function
4655 .section .gcc_except_table.foo,"a",@progbits
4658 .section .eh_frame,"a",@progbits
4661 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4662 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4663 | grep "gc-sections option ignored" > /dev/null; then
4665 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4666 | grep gcc_except_table > /dev/null; then
4667 gcc_cv_ld_eh_gc_sections_bug=no
4670 rm -f conftest.s conftest.o conftest
4672 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4673 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4674 [Define if your linker has buggy garbage collection of
4675 sections support when .text.startup.foo like sections are used.])
4677 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4683 AC_CACHE_CHECK(linker --as-needed support,
4684 gcc_cv_ld_as_needed,
4685 [gcc_cv_ld_as_needed=no
4686 gcc_cv_ld_as_needed_option='--as-needed'
4687 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4688 if test $in_tree_ld = yes ; then
4689 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 \
4690 && test $in_tree_ld_is_elf = yes; then
4691 gcc_cv_ld_as_needed=yes
4693 elif test x$gcc_cv_ld != x; then
4694 # Check if linker supports --as-needed and --no-as-needed options
4695 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4696 gcc_cv_ld_as_needed=yes
4699 # Solaris 2 ld always supports -z ignore/-z record.
4701 gcc_cv_ld_as_needed=yes
4702 gcc_cv_ld_as_needed_option="-z ignore"
4703 gcc_cv_ld_no_as_needed_option="-z record"
4708 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4709 # dl_iterate_phdr, i.e. since Solaris 11.
4711 *-*-solaris2.1[[1-9]]*)
4713 i?86-*-* | x86_64-*-*)
4714 if echo "$ld_ver" | grep GNU > /dev/null; then
4715 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4716 gcc_cv_ld_as_needed=no
4722 gcc_cv_ld_as_needed=no
4726 if test x"$gcc_cv_ld_as_needed" = xyes; then
4727 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4728 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4729 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4730 [Define to the linker option to ignore unused dependencies.])
4731 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4732 [Define to the linker option to keep unused dependencies.])
4735 case "$target:$tm_file" in
4736 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4739 emul_name="-melf64lppc"
4742 emul_name="-melf64ppc"
4745 emul_name="-melf64ppc_fbsd"
4748 AC_CACHE_CHECK(linker support for omitting dot symbols,
4749 gcc_cv_ld_no_dot_syms,
4750 [gcc_cv_ld_no_dot_syms=no
4751 if test x"$ld_is_gold" = xyes; then
4752 gcc_cv_ld_no_dot_syms=yes
4753 elif test $in_tree_ld = yes ; then
4754 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
4755 gcc_cv_ld_no_dot_syms=yes
4757 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4758 cat > conftest1.s <<EOF
4762 cat > conftest2.s <<EOF
4763 .section ".opd","aw"
4768 .quad .LEfoo,.TOC.@tocbase,0
4774 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4775 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4776 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4777 gcc_cv_ld_no_dot_syms=yes
4779 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4782 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4783 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4784 [Define if your PowerPC64 linker only needs function descriptor syms.])
4787 AC_CACHE_CHECK(linker large toc support,
4788 gcc_cv_ld_large_toc,
4789 [gcc_cv_ld_large_toc=no
4790 if test x"$ld_is_gold" = xyes; then
4791 gcc_cv_ld_large_toc=yes
4792 elif test $in_tree_ld = yes ; then
4793 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
4794 gcc_cv_ld_large_toc=yes
4796 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4797 cat > conftest.s <<EOF
4798 .section ".tbss","awT",@nobits
4804 addis 9,13,ie0@got@tprel@ha
4805 ld 9,ie0@got@tprel@l(9)
4807 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4808 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4809 gcc_cv_ld_large_toc=yes
4811 rm -f conftest conftest.o conftest.s
4814 if test x"$gcc_cv_ld_large_toc" = xyes; then
4815 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4816 [Define if your PowerPC64 linker supports a large TOC.])
4823 AC_CACHE_CHECK(linker large toc support,
4824 gcc_cv_ld_large_toc,
4825 [gcc_cv_ld_large_toc=no
4826 if test x$gcc_cv_as != x ; then
4827 cat > conftest.s <<EOF
4837 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4838 gcc_cv_ld_large_toc=yes
4840 rm -f conftest conftest.o conftest.s
4843 if test x"$gcc_cv_ld_large_toc" = xyes; then
4844 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4845 [Define if your PowerPC64 linker supports a large TOC.])
4850 AC_CACHE_CHECK(linker --build-id support,
4852 [gcc_cv_ld_buildid=no
4853 if test $in_tree_ld = yes ; then
4854 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4855 "$gcc_cv_gld_minor_version" -ge 18 -o \
4856 "$gcc_cv_gld_major_version" -gt 2 \
4857 && test $in_tree_ld_is_elf = yes; then
4858 gcc_cv_ld_buildid=yes
4860 elif test x$gcc_cv_ld != x; then
4861 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4862 gcc_cv_ld_buildid=yes
4865 if test x"$gcc_cv_ld_buildid" = xyes; then
4866 AC_DEFINE(HAVE_LD_BUILDID, 1,
4867 [Define if your linker supports --build-id.])
4870 AC_ARG_ENABLE(linker-build-id,
4871 [AS_HELP_STRING([--enable-linker-build-id],
4872 [compiler will always pass --build-id to linker])],
4874 enable_linker_build_id=no)
4876 if test x"$enable_linker_build_id" = xyes; then
4877 if test x"$gcc_cv_ld_buildid" = xyes; then
4878 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4879 [Define if gcc should always pass --build-id to linker.])
4881 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4885 # In binutils 2.21, GNU ld gained support for new emulations fully
4886 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4887 AC_CACHE_CHECK(linker *_sol2 emulation support,
4888 gcc_cv_ld_sol2_emulation,
4889 [gcc_cv_ld_sol2_emulation=no
4890 if test $in_tree_ld = yes ; then
4891 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4892 "$gcc_cv_gld_minor_version" -ge 21 -o \
4893 "$gcc_cv_gld_major_version" -gt 2 \
4894 && test $in_tree_ld_is_elf = yes; then
4895 gcc_cv_ld_sol2_emulation=yes
4897 elif test x$gcc_cv_ld != x; then
4898 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4899 grep _sol2 > /dev/null; then
4900 gcc_cv_ld_sol2_emulation=yes
4903 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4904 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4905 [Define if your linker supports the *_sol2 emulations.])
4908 AC_CACHE_CHECK(linker --sysroot support,
4910 [gcc_cv_ld_sysroot=no
4911 if test $in_tree_ld = yes ; then
4912 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
4913 gcc_cv_ld_sysroot=yes
4915 elif test x$gcc_cv_ld != x; then
4916 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4917 gcc_cv_ld_sysroot=yes
4920 if test x"$gcc_cv_ld_sysroot" = xyes; then
4921 AC_DEFINE(HAVE_LD_SYSROOT, 1,
4922 [Define if your linker supports --sysroot.])
4925 # Test for stack protector support in target C library.
4926 AC_CACHE_CHECK(__stack_chk_fail in target C library,
4927 gcc_cv_libc_provides_ssp,
4928 [gcc_cv_libc_provides_ssp=no
4930 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
4931 # glibc 2.4 and later provides __stack_chk_fail and
4932 # either __stack_chk_guard, or TLS access to stack guard canary.
4933 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
4934 [if test -f $target_header_dir/features.h \
4935 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
4936 $target_header_dir/features.h > /dev/null; then
4937 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
4938 $target_header_dir/features.h > /dev/null && \
4939 test -f $target_header_dir/bits/uClibc_config.h && \
4940 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
4941 $target_header_dir/bits/uClibc_config.h > /dev/null; then
4942 gcc_cv_libc_provides_ssp=yes
4944 # all versions of Bionic support stack protector
4945 elif test -f $target_header_dir/sys/cdefs.h \
4946 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
4947 $target_header_dir/sys/cdefs.h > /dev/null; then
4948 gcc_cv_libc_provides_ssp=yes
4952 # Avoid complicated tests (see
4953 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
4954 # simply assert that glibc does provide this, which is true for all
4955 # realistically usable GNU/Hurd configurations.
4956 gcc_cv_libc_provides_ssp=yes;;
4957 *-*-darwin* | *-*-freebsd*)
4958 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
4959 [echo "no __stack_chk_fail on this target"])
4961 *) gcc_cv_libc_provides_ssp=no ;;
4964 if test x$gcc_cv_libc_provides_ssp = xyes; then
4965 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
4966 [Define if your target C library provides stack protector support])
4969 # Test for <sys/sdt.h> on the target.
4970 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
4971 AC_MSG_CHECKING(sys/sdt.h in the target C library)
4973 if test -f $target_header_dir/sys/sdt.h; then
4975 AC_DEFINE(HAVE_SYS_SDT_H, 1,
4976 [Define if your target C library provides sys/sdt.h])
4978 AC_MSG_RESULT($have_sys_sdt_h)
4980 # Check if TFmode long double should be used by default or not.
4981 # Some glibc targets used DFmode long double, but with glibc 2.4
4982 # and later they can use TFmode.
4984 powerpc*-*-linux* | \
4988 AC_ARG_WITH(long-double-128,
4989 [AS_HELP_STRING([--with-long-double-128],
4990 [use 128-bit long double by default])],
4991 gcc_cv_target_ldbl128="$with_long_double_128",
4992 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
4993 [gcc_cv_target_ldbl128=no
4994 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
4995 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
4996 && gcc_cv_target_ldbl128=yes
5000 if test x$gcc_cv_target_ldbl128 = xyes; then
5001 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5002 [Define if TFmode long double should be the default])
5005 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5006 gcc_cv_target_dl_iterate_phdr=unknown
5008 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5009 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5010 # libdl there, both complicating its use and breaking compatibility
5011 # between Solaris 10 updates.
5012 *-*-solaris2.1[[1-9]]*)
5013 # <link.h> needs both a dl_iterate_phdr declaration and support for
5014 # compilation with largefile support.
5015 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5016 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5017 gcc_cv_target_dl_iterate_phdr=yes
5019 gcc_cv_target_dl_iterate_phdr=no
5022 *-*-dragonfly* | *-*-freebsd*)
5023 if grep dl_iterate_phdr $target_header_dir/sys/link_elf.h > /dev/null 2>&1; then
5024 gcc_cv_target_dl_iterate_phdr=yes
5026 gcc_cv_target_dl_iterate_phdr=no
5030 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5031 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5032 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5033 [Define if your target C library provides the `dl_iterate_phdr' function.])
5035 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5037 # We no longer support different GC mechanisms. Emit an error if
5038 # the user configures with --with-gc.
5040 [AS_HELP_STRING([--with-gc={page,zone}],
5041 [this option is not supported anymore. It used to choose
5042 the garbage collection mechanism to use with the compiler])],
5043 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5046 # Libraries to use on the host. This will normally be set by the top
5047 # level Makefile. Here we simply capture the value for our Makefile.
5048 if test -z "${HOST_LIBS+set}"; then
5053 # Use the system's zlib library.
5055 zlibinc="-I\$(srcdir)/../zlib"
5056 AC_ARG_WITH(system-zlib,
5057 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5064 dnl Very limited version of automake's enable-maintainer-mode
5066 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5067 dnl maintainer-mode is disabled by default
5068 AC_ARG_ENABLE(maintainer-mode,
5069 [AS_HELP_STRING([--enable-maintainer-mode],
5070 [enable make rules and dependencies not useful
5071 (and sometimes confusing) to the casual installer])],
5072 maintainer_mode=$enableval,
5075 AC_MSG_RESULT($maintainer_mode)
5077 if test "$maintainer_mode" = "yes"; then
5084 dnl Whether to prevent multiple front-ends from linking at the same time
5086 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5087 AC_ARG_ENABLE(link-mutex,
5088 [AS_HELP_STRING([--enable-link-mutex],
5089 [avoid linking multiple front-ends at once to avoid thrashing
5090 on the build machine])],
5091 do_link_mutex=$enableval,
5093 AC_MSG_RESULT($do_link_mutex)
5095 if test "$do_link_mutex" = "yes"; then
5100 AC_SUBST(DO_LINK_MUTEX)
5106 # Make empty files to contain the specs and options for each language.
5107 # Then add #include lines to for a compiler that has specs and/or options.
5113 # These (without "all_") are set in each config-lang.in.
5114 # `language' must be a single word so is spelled singularly.
5117 all_outputs='Makefile'
5118 # List of language makefile fragments.
5120 # Additional files for gengtype
5121 all_gtfiles="$target_gtfiles"
5123 # These are the languages that are set in --enable-languages,
5124 # and are available in the GCC tree.
5125 all_selected_languages=
5127 # Add the language fragments.
5128 # Languages are added via two mechanisms. Some information must be
5129 # recorded in makefile variables, these are defined in config-lang.in.
5130 # We accumulate them and plug them into the main Makefile.
5131 # The other mechanism is a set of hooks for each of the main targets
5132 # like `clean', `install', etc.
5134 language_hooks="Make-hooks"
5136 for lang in ${srcdir}/*/config-lang.in
5139 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5141 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5142 if test "x$lang_alias" = x
5144 echo "$lang doesn't set \$language." 1>&2
5147 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5148 subdirs="$subdirs $subdir"
5150 # $gcc_subdir is where the gcc integration files are to be found
5151 # for a language, both for internal compiler purposes (compiler
5152 # sources implementing front-end to GCC tree converters), and for
5153 # build infrastructure purposes (Make-lang.in, etc.)
5155 # This will be <subdir> (relative to $srcdir) if a line like
5156 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5157 # is found in <langdir>/config-lang.in, and will remain <langdir>
5160 # Except for the language alias (fetched above), the regular
5161 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5162 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5163 # only this and the language alias.
5165 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5166 if [ "$gcc_subdir" = "" ]; then
5167 gcc_subdir="$subdir"
5170 case ",$enable_languages," in
5172 all_selected_languages="$all_selected_languages $lang_alias"
5173 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5174 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5186 . ${srcdir}/$gcc_subdir/config-lang.in
5187 if test "x$language" = x
5189 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5194 case ",$enable_languages," in
5197 for i in $subdir_requires; do
5198 test -f "${srcdir}/$i/config-lang.in" && continue
5206 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5207 if test -f $srcdir/$gcc_subdir/lang.opt; then
5208 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5209 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5211 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5212 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5214 all_languages="$all_languages $language"
5215 all_compilers="$all_compilers $compilers"
5216 all_outputs="$all_outputs $outputs"
5217 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5218 case ",$enable_languages," in
5220 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5222 AC_SUBST(enable_lto)
5229 for language in $all_selected_languages
5231 check_languages="$check_languages check-$language"
5234 # We link each language in with a set of hooks, reached indirectly via
5235 # lang.${target}. Only do so for selected languages.
5239 target_list="all.cross start.encap rest.encap tags \
5240 install-common install-man install-info install-pdf install-html dvi \
5241 pdf html uninstall info man srcextra srcman srcinfo \
5242 mostlyclean clean distclean maintainer-clean install-plugin"
5244 for t in $target_list
5247 for lang in $all_selected_languages
5251 echo "lang.$t: $x" >> Make-hooks
5255 # Option include files
5258 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5259 option_includes="option-includes.mk"
5260 AC_SUBST_FILE(option_includes)
5268 echo "dir ." > .gdbinit
5269 echo "dir ${srcdir}" >> .gdbinit
5270 if test x$gdb_needs_out_file_path = xyes
5272 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5274 if test "x$subdirs" != x; then
5277 echo "dir ${srcdir}/$s" >> .gdbinit
5280 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5281 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5283 # Put a breakpoint on __asan_report_error to help with debugging buffer
5286 *-fsanitize=address*)
5287 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5291 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5292 AC_SUBST(gcc_tooldir)
5295 # Find a directory in which to install a shared libgcc.
5297 AC_ARG_ENABLE(version-specific-runtime-libs,
5298 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5299 [specify that runtime libraries should be
5300 installed in a compiler-specific directory])])
5302 # Substitute configuration variables
5305 AC_SUBST(all_compilers)
5306 AC_SUBST(all_gtfiles)
5307 AC_SUBST(all_lang_makefrags)
5308 AC_SUBST(all_languages)
5309 AC_SUBST(all_selected_languages)
5310 AC_SUBST(build_exeext)
5311 AC_SUBST(build_install_headers_dir)
5312 AC_SUBST(build_xm_file_list)
5313 AC_SUBST(build_xm_include_list)
5314 AC_SUBST(build_xm_defines)
5315 AC_SUBST(build_file_translate)
5316 AC_SUBST(check_languages)
5317 AC_SUBST(cpp_install_dir)
5318 AC_SUBST(xmake_file)
5319 AC_SUBST(tmake_file)
5320 AC_SUBST(TM_ENDIAN_CONFIG)
5321 AC_SUBST(TM_MULTILIB_CONFIG)
5322 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5323 AC_SUBST(extra_gcc_objs)
5324 AC_SUBST(user_headers_inc_next_pre)
5325 AC_SUBST(user_headers_inc_next_post)
5326 AC_SUBST(extra_headers_list)
5327 AC_SUBST(extra_objs)
5328 AC_SUBST(extra_programs)
5329 AC_SUBST(float_h_file)
5330 AC_SUBST(gcc_config_arguments)
5331 AC_SUBST(gcc_gxx_include_dir)
5332 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5333 AC_SUBST(host_exeext)
5334 AC_SUBST(host_xm_file_list)
5335 AC_SUBST(host_xm_include_list)
5336 AC_SUBST(host_xm_defines)
5337 AC_SUBST(out_host_hook_obj)
5339 AC_SUBST(lang_opt_files)
5340 AC_SUBST(lang_specs_files)
5341 AC_SUBST(lang_tree_files)
5342 AC_SUBST(local_prefix)
5344 AC_SUBST(objc_boehm_gc)
5346 AC_SUBST(out_object_file)
5347 AC_SUBST(common_out_file)
5348 AC_SUBST(common_out_object_file)
5349 AC_SUBST(tm_file_list)
5350 AC_SUBST(tm_include_list)
5351 AC_SUBST(tm_defines)
5352 AC_SUBST(tm_p_file_list)
5353 AC_SUBST(tm_p_include_list)
5354 AC_SUBST(xm_file_list)
5355 AC_SUBST(xm_include_list)
5356 AC_SUBST(xm_defines)
5357 AC_SUBST(use_gcc_stdint)
5358 AC_SUBST(c_target_objs)
5359 AC_SUBST(cxx_target_objs)
5360 AC_SUBST(fortran_target_objs)
5361 AC_SUBST(target_cpu_default)
5363 AC_SUBST_FILE(language_hooks)
5366 if test x${build} = x${host} ; then
5367 if test x${host} = x${target} ; then
5368 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5370 echo "Links are now set up to build a cross-compiler" 1>&2
5371 echo " from ${host} to ${target}." 1>&2
5374 if test x${host} = x${target} ; then
5375 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5376 echo " for ${target}." 1>&2
5378 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5379 echo " from ${host} to ${target}." 1>&2
5383 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5384 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5386 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5387 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5389 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5390 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5391 if test "x${CLOOGLIBS}" != "x" ; then
5392 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5395 # Check for plugin support
5396 AC_ARG_ENABLE(plugin,
5397 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5398 enable_plugin=$enableval,
5399 enable_plugin=yes; default_plugin=yes)
5405 if test x$build = x$host; then
5406 export_sym_check="nm${exeext} -g"
5407 elif test x$host = x$target; then
5408 export_sym_check="$gcc_cv_nm -g"
5414 if test x$build = x$host; then
5415 export_sym_check="objdump${exeext} -T"
5416 elif test x$host = x$target; then
5417 export_sym_check="$gcc_cv_objdump -T"
5424 if test x"$enable_plugin" = x"yes"; then
5426 AC_MSG_CHECKING([for exported symbols])
5427 if test "x$export_sym_check" != x; then
5428 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5429 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5430 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5431 : # No need to use a flag
5432 AC_MSG_RESULT([yes])
5434 AC_MSG_RESULT([yes])
5435 AC_MSG_CHECKING([for -rdynamic])
5436 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5437 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5439 pluginlibs="-rdynamic"
5444 AC_MSG_RESULT([$plugin_rdynamic])
5447 AC_MSG_RESULT([unable to check])
5452 AC_SEARCH_LIBS([dlopen], [dl])
5453 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5454 pluginlibs="$pluginlibs -ldl"
5458 # Check that we can build shared objects with -fPIC -shared
5459 saved_LDFLAGS="$LDFLAGS"
5460 saved_CFLAGS="$CFLAGS"
5463 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5464 CFLAGS="$CFLAGS -fPIC"
5465 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5468 CFLAGS="$CFLAGS -fPIC"
5469 LDFLAGS="$LDFLAGS -fPIC -shared"
5472 AC_MSG_CHECKING([for -fPIC -shared])
5474 [extern int X;],[return X == 0;],
5475 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5476 [AC_MSG_RESULT([no]); have_pic_shared=no])
5477 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5481 LDFLAGS="$saved_LDFLAGS"
5482 CFLAGS="$saved_CFLAGS"
5484 # If plugin support had been requested but not available, fail.
5485 if test x"$enable_plugin" = x"no" ; then
5486 if test x"$default_plugin" != x"yes"; then
5488 Building GCC with plugin support requires a host that supports
5489 -fPIC, -shared, -ldl and -rdynamic.])
5494 AC_SUBST(pluginlibs)
5495 AC_SUBST(enable_plugin)
5496 if test x"$enable_plugin" = x"yes"; then
5497 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5501 # Enable --enable-host-shared
5502 AC_ARG_ENABLE(host-shared,
5503 [AS_HELP_STRING([--enable-host-shared],
5504 [build host code as shared libraries])],
5505 [PICFLAG=-fPIC], [PICFLAG=])
5506 AC_SUBST(enable_host_shared)
5510 AC_ARG_ENABLE(libquadmath-support,
5511 [AS_HELP_STRING([--disable-libquadmath-support],
5512 [disable libquadmath support for Fortran])],
5513 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5514 ENABLE_LIBQUADMATH_SUPPORT=yes)
5515 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5516 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5517 [Define to 1 to enable libquadmath support])
5521 # Specify what hash style to use by default.
5522 AC_ARG_WITH([linker-hash-style],
5523 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5524 [specify the linker hash style])],
5525 [case x"$withval" in
5527 LINKER_HASH_STYLE=sysv
5530 LINKER_HASH_STYLE=gnu
5533 LINKER_HASH_STYLE=both
5536 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5539 [LINKER_HASH_STYLE=''])
5540 if test x"${LINKER_HASH_STYLE}" != x; then
5541 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5542 [The linker hash style])
5545 # Configure the subdirectories
5546 # AC_CONFIG_SUBDIRS($subdirs)
5548 # Create the Makefile
5549 # and configure language subdirectories
5550 AC_CONFIG_FILES($all_outputs)
5552 AC_CONFIG_COMMANDS([default],
5554 case ${CONFIG_HEADERS} in
5555 *auto-host.h:config.in*)
5558 # Make sure all the subdirs exist.
5559 for d in $subdirs doc build common c-family
5561 test -d $d || mkdir $d
5564 [subdirs='$subdirs'])