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 if test x$ac_valgrind_checking != x ; then
518 # It is certainly possible that there's valgrind but no valgrind.h.
519 # GCC relies on making annotations so we must have both.
520 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
521 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
522 [[#include <valgrind/memcheck.h>
523 #ifndef VALGRIND_DISCARD
524 #error VALGRIND_DISCARD not defined
526 [gcc_cv_header_valgrind_memcheck_h=yes],
527 [gcc_cv_header_valgrind_memcheck_h=no])
528 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
529 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
530 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
531 [[#include <memcheck.h>
532 #ifndef VALGRIND_DISCARD
533 #error VALGRIND_DISCARD not defined
535 [gcc_cv_header_memcheck_h=yes],
536 [gcc_cv_header_memcheck_h=no])
537 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
538 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
539 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
540 if test "x$valgrind_path" = "x" \
541 || (test $have_valgrind_h = no \
542 && test $gcc_cv_header_memcheck_h = no \
543 && test $gcc_cv_header_valgrind_memcheck_h = no); then
544 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
546 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
547 valgrind_command="$valgrind_path -q"
548 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
549 [Define if you want to run subprograms and generated programs
550 through valgrind (a memory checker). This is extremely expensive.])
551 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
552 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
553 [Define if valgrind's valgrind/memcheck.h header is installed.])
555 if test $gcc_cv_header_memcheck_h = yes; then
556 AC_DEFINE(HAVE_MEMCHECK_H, 1,
557 [Define if valgrind's memcheck.h header is installed.])
560 AC_SUBST(valgrind_path_defines)
561 AC_SUBST(valgrind_command)
563 # Enable code coverage collection
564 AC_ARG_ENABLE(coverage,
565 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
566 [enable compiler's code coverage collection.
567 Use to measure compiler performance and locate
568 unused parts of the compiler. With LEVEL, specify
569 optimization. Values are opt, noopt,
571 [case "${enableval}" in
573 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
576 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
579 # a.k.a. --disable-coverage
583 AC_MSG_ERROR(unknown coverage setting $enableval)
587 AC_SUBST(coverage_flags)
589 AC_ARG_ENABLE(gather-detailed-mem-stats,
590 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
591 [enable detailed memory allocation stats gathering])], [],
592 [enable_gather_detailed_mem_stats=no])
593 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
594 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
595 [Define to enable detailed memory allocation stats gathering.])
597 # -------------------------------
598 # Miscenalleous configure options
599 # -------------------------------
603 [AS_HELP_STRING([--with-stabs],
604 [arrange to use stabs instead of host debug format])],
608 # Determine whether or not multilibs are enabled.
609 AC_ARG_ENABLE(multilib,
610 [AS_HELP_STRING([--enable-multilib],
611 [enable library support for multiple ABIs])],
612 [], [enable_multilib=yes])
613 AC_SUBST(enable_multilib)
615 # Determine whether or not multiarch is enabled.
616 AC_ARG_ENABLE(multiarch,
617 [AS_HELP_STRING([--enable-multiarch],
618 [enable support for multiarch paths])],
619 [case "${enableval}" in
620 yes|no|auto) enable_multiarch=$enableval;;
621 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
622 esac], [enable_multiarch=auto])
623 if test x${enable_multiarch} = xauto; then
624 if test x${with_native_system_header_dir} != x; then
625 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
628 if test x$host != x$target && test "x$with_sysroot" = x; then
629 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
633 AC_MSG_CHECKING(for multiarch configuration)
634 AC_SUBST(enable_multiarch)
635 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
637 # needed for setting the multiarch name for soft-float/hard-float ABIs
641 # Enable __cxa_atexit for C++.
642 AC_ARG_ENABLE(__cxa_atexit,
643 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
646 # Enable C extension for decimal float if target supports it.
647 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
649 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
650 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
651 [Define to 1 to enable decimal float extension to C.])
653 # Use default_decimal_float for dependency.
654 enable_decimal_float=$default_decimal_float
656 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
657 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
658 [Define to 1 to specify that we are using the BID decimal floating
659 point format instead of DPD])
661 # Enable C extension for fixed-point arithmetic.
662 AC_ARG_ENABLE(fixed-point,
663 [AS_HELP_STRING([--enable-fixed-point],
664 [enable fixed-point arithmetic extension to C])],
669 enable_fixed_point=yes
673 enable_fixed_point=yes
676 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
677 enable_fixed_point=no
681 AC_SUBST(enable_fixed_point)
683 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
684 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
685 [Define to 1 to enable fixed-point arithmetic extension to C.])
688 # Pass with no value to take the default
689 # Pass with a value to specify a thread package
690 AC_ARG_ENABLE(threads,
691 [AS_HELP_STRING([[--enable-threads[=LIB]]],
692 [enable thread usage for target GCC,
693 using LIB thread package])],,
697 [AS_HELP_STRING([--enable-tls],
698 [enable or disable generation of tls code
699 overriding the assembler check for tls support])],
703 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
704 Valid choices are 'yes' and 'no'.]) ;;
708 AC_ARG_ENABLE(objc-gc,
709 [AS_HELP_STRING([--enable-objc-gc],
710 [enable the use of Boehm's garbage collector with
711 the GNU Objective-C runtime])],
712 if test x$enable_objc_gc = xno; then
720 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
721 dwarf2="$with_dwarf2",
724 AC_ARG_ENABLE(shared,
725 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
727 case $enable_shared in
731 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
732 for pkg in $enableval; do
733 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
740 ], [enable_shared=yes])
741 AC_SUBST(enable_shared)
743 AC_ARG_WITH([native-system-header-dir],
744 [ --with-native-system-header-dir=dir
745 use dir as the directory to look for standard
746 system header files in. Defaults to /usr/include.],
748 case ${with_native_system_header_dir} in
749 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
750 /* | [[A-Za-z]]:[[\\/]]*) ;;
751 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
753 configured_native_system_header_dir="${withval}"
754 ], [configured_native_system_header_dir=])
756 AC_ARG_WITH(build-sysroot,
757 [AS_HELP_STRING([--with-build-sysroot=sysroot],
758 [use sysroot as the system root during the build])],
759 [if test x"$withval" != x ; then
760 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
762 [SYSROOT_CFLAGS_FOR_TARGET=])
763 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
765 if test "x$prefix" = xNONE; then
766 test_prefix=/usr/local
770 if test "x$exec_prefix" = xNONE; then
771 test_exec_prefix=$test_prefix
773 test_exec_prefix=$exec_prefix
777 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
778 [search for usr/lib, usr/include, et al, within DIR])],
780 case ${with_sysroot} in
781 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
782 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
785 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
786 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
788 case ${TARGET_SYSTEM_ROOT} in
789 "${test_prefix}"|"${test_prefix}/"*|\
790 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
791 '${prefix}'|'${prefix}/'*|\
792 '${exec_prefix}'|'${exec_prefix}/'*)
793 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
794 TARGET_SYSTEM_ROOT_DEFINE="$t"
799 TARGET_SYSTEM_ROOT_DEFINE=
800 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
802 AC_SUBST(TARGET_SYSTEM_ROOT)
803 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
804 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
807 [AS_HELP_STRING([--with-specs=SPECS],
808 [add SPECS to driver command-line processing])],
809 [CONFIGURE_SPECS=$withval],
812 AC_SUBST(CONFIGURE_SPECS)
814 ACX_PKGVERSION([GCC])
815 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
817 # Sanity check enable_languages in case someone does not run the toplevel
818 # configure # script.
819 AC_ARG_ENABLE(languages,
820 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
821 [case ,${enable_languages}, in
823 # go safe -- we cannot be much sure without the toplevel
825 # analysis of which target libs are present and usable
829 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
834 enable_languages=c,${enable_languages}
837 [enable_languages=c])
839 AC_ARG_WITH(multilib-list,
840 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
842 with_multilib_list=default)
844 # -------------------------
845 # Checks for other programs
846 # -------------------------
850 # Find some useful tools
852 # We need awk to create options.c and options.h.
853 # Bail out if it's missing.
855 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
862 AC_SUBST(ranlib_flags)
866 # See if cmp has --ignore-initial.
867 gcc_AC_PROG_CMP_IGNORE_INITIAL
869 # See if we have the mktemp command.
870 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
872 # See if makeinfo has been installed and is modern enough
873 # that we can use it.
874 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
875 [GNU texinfo.* \([0-9][0-9.]*\)],
876 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
877 if test $gcc_cv_prog_makeinfo_modern = no; then
879 *** Makeinfo is missing or too old.
880 *** Info documentation will not be built.])
887 # Is pod2man recent enough to regenerate manpages?
888 AC_MSG_CHECKING([for recent Pod::Man])
889 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
891 GENERATED_MANPAGES=generated-manpages
896 AC_SUBST(GENERATED_MANPAGES)
898 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
901 dnl Don't use AC_PROG_LEX; we insist on flex.
902 dnl LEXLIB is not useful in gcc.
903 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
906 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
908 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
909 # check for build == host before using them.
912 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
913 && test -d ../binutils ; then
914 NM='${objdir}/../binutils/nm-new'
916 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
920 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
921 && test -d ../binutils ; then
922 AR='${objdir}/../binutils/ar'
924 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
928 # --------------------
929 # Checks for C headers
930 # --------------------
932 # Need to reject headers which give warnings, so that the -Werror bootstrap
933 # works later. *sigh* This needs to come before all header checks.
941 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
942 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
943 sys/resource.h sys/param.h sys/times.h sys/stat.h \
944 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
946 # Check for thread headers.
947 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
948 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
950 # These tests can't be done till we know if we have limits.h.
954 # ----------------------
955 # Checks for C++ headers
956 # ----------------------
958 dnl Autoconf will give an error in the configure script if there is no
959 dnl C++ preprocessor. Hack to prevent that.
960 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
962 m4_popdef([AC_MSG_ERROR])[]dnl
966 AC_CHECK_HEADERS(unordered_map)
967 AC_CHECK_HEADERS(tr1/unordered_map)
968 AC_CHECK_HEADERS(ext/hash_map)
973 # Dependency checking.
978 AC_CONFIG_COMMANDS([gccdepdir],[
979 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
980 for lang in $subdirs c-family common
982 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
983 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
985 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
993 # These libraries may be used by collect2.
994 # We may need a special search path to get them linked.
995 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
997 for libs in '' -lld -lmld \
998 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
999 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1002 AC_TRY_LINK_FUNC(ldopen,
1003 [gcc_cv_collect2_libs="$libs"; break])
1006 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1007 case $gcc_cv_collect2_libs in
1009 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1011 AC_SUBST(COLLECT2_LIBS)
1013 # When building Ada code on Alpha, we need exc_resume which is usually in
1014 # -lexc. So test for it.
1017 AC_SEARCH_LIBS(exc_resume, exc)
1020 AC_SUBST(GNAT_LIBEXC)
1022 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1025 AC_SEARCH_LIBS(kstat_open, kstat)
1026 EXTRA_GCC_LIBS="$LIBS"
1028 AC_SUBST(EXTRA_GCC_LIBS)
1030 # Some systems put ldexp and frexp in libm instead of libc; assume
1031 # they're both in the same place. jcf-dump needs them.
1034 AC_SEARCH_LIBS(ldexp, m)
1039 # Use <inttypes.h> only if it exists,
1040 # doesn't clash with <sys/types.h>, and declares intmax_t.
1041 AC_MSG_CHECKING(for inttypes.h)
1042 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1043 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1044 [[#include <sys/types.h>
1045 #include <inttypes.h>]],
1046 [[intmax_t i = -1;]])],
1047 [gcc_cv_header_inttypes_h=yes],
1048 [gcc_cv_header_inttypes_h=no])])
1049 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1050 if test $gcc_cv_header_inttypes_h = yes; then
1051 AC_DEFINE(HAVE_INTTYPES_H, 1,
1052 [Define if you have a working <inttypes.h> header file.])
1055 dnl Disabled until we have a complete test for buggy enum bitfields.
1056 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1058 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1059 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1060 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1061 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1062 putchar_unlocked putc_unlocked)
1063 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1064 sysconf strsignal getrusage nl_langinfo \
1065 gettimeofday mbstowcs wcswidth mmap setlocale \
1066 gcc_UNLOCKED_FUNCS madvise)
1068 if test x$ac_cv_func_mbstowcs = xyes; then
1069 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1070 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1076 [gcc_cv_func_mbstowcs_works=yes],
1077 [gcc_cv_func_mbstowcs_works=no],
1078 [gcc_cv_func_mbstowcs_works=yes])])
1079 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1080 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1081 [Define this macro if mbstowcs does not crash when its
1082 first argument is NULL.])
1086 AC_CHECK_TYPE(ssize_t, int)
1087 AC_CHECK_TYPE(caddr_t, char *)
1089 GCC_AC_FUNC_MMAP_BLACKLIST
1093 # Under VMS, vfork works very differently than on Unix. The standard test
1094 # won't work, and it isn't easily adaptable. It makes more sense to
1096 ac_cv_func_vfork_works=yes
1101 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1102 # iconv() prototype.
1107 # Until we have in-tree GNU iconv:
1109 AC_SUBST(LIBICONV_DEP)
1115 # We will need to find libiberty.h and ansidecl.h
1116 saved_CFLAGS="$CFLAGS"
1117 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1118 saved_CXXFLAGS="$CXXFLAGS"
1119 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1120 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1121 strsignal strstr stpcpy strverscmp \
1122 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1123 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1124 #include "ansidecl.h"
1125 #include "system.h"])
1127 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1128 #include "ansidecl.h"
1130 #ifdef HAVE_SYS_RESOURCE_H
1131 #include <sys/resource.h>
1135 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1136 #include "ansidecl.h"
1138 #ifdef HAVE_SYS_RESOURCE_H
1139 #include <sys/resource.h>
1141 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1142 [Define to `long' if <sys/resource.h> doesn't define.])])
1144 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1145 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1146 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1147 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1148 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1149 #include "ansidecl.h"
1158 gcc_AC_CHECK_DECLS(times, , ,[
1159 #include "ansidecl.h"
1161 #ifdef HAVE_SYS_TIMES_H
1162 #include <sys/times.h>
1166 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1167 #include "ansidecl.h"
1172 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1175 gcc_AC_CHECK_DECLS(madvise, , ,[
1176 #include "ansidecl.h"
1181 # More time-related stuff.
1182 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1183 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1184 #include "ansidecl.h"
1186 #ifdef HAVE_SYS_TIMES_H
1187 #include <sys/times.h>
1189 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1190 if test $ac_cv_struct_tms = yes; then
1191 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1192 [Define if <sys/times.h> defines struct tms.])
1195 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1196 # revisit after autoconf 2.50.
1197 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1198 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1199 #include "ansidecl.h"
1201 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1202 if test $gcc_cv_type_clock_t = yes; then
1203 AC_DEFINE(HAVE_CLOCK_T, 1,
1204 [Define if <time.h> defines clock_t.])
1207 # Check if F_SETLKW is supported by fcntl.
1208 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1209 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1210 #include <fcntl.h>]], [[
1216 return fcntl (1, F_SETLKW, &fl);]])],
1217 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1218 if test $ac_cv_f_setlkw = yes; then
1219 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1220 [Define if F_SETLKW supported by fcntl.])
1223 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1224 CFLAGS="$saved_CFLAGS"
1225 CXXFLAGS="$saved_CXXFLAGS"
1227 # mkdir takes a single argument on some systems.
1228 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1236 # With Setjmp/Longjmp based exception handling.
1237 AC_ARG_ENABLE(sjlj-exceptions,
1238 [AS_HELP_STRING([--enable-sjlj-exceptions],
1239 [arrange to use setjmp/longjmp exception handling])],
1242 if test $enableval != yes; then
1243 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1248 force_sjlj_exceptions=yes],
1251 force_sjlj_exceptions=yes
1255 force_sjlj_exceptions=yes
1259 force_sjlj_exceptions=no
1262 if test $force_sjlj_exceptions = yes; then
1263 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1264 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1265 [Define 0/1 to force the choice for exception handling model.])
1268 # --------------------------------------------------------
1269 # Build, host, and target specific configuration fragments
1270 # --------------------------------------------------------
1272 # Collect build-machine-specific information.
1273 . ${srcdir}/config.build
1275 # Collect host-machine-specific information.
1276 . ${srcdir}/config.host
1280 # Collect target-machine-specific information.
1281 . ${srcdir}/config.gcc
1283 extra_objs="${host_extra_objs} ${extra_objs}"
1284 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1286 # Default the target-machine variables that were not explicitly set.
1287 if test x"$tm_file" = x
1288 then tm_file=$cpu_type/$cpu_type.h; fi
1290 if test x"$extra_headers" = x
1291 then extra_headers=; fi
1293 if test x$md_file = x
1294 then md_file=$cpu_type/$cpu_type.md; fi
1296 if test x$out_file = x
1297 then out_file=$cpu_type/$cpu_type.c; fi
1299 if test x"$tmake_file" = x
1300 then tmake_file=$cpu_type/t-$cpu_type
1303 # Support --enable-initfini-array.
1304 if test x$enable_initfini_array != xno; then
1305 tm_file="${tm_file} initfini-array.h"
1308 if test x"$dwarf2" = xyes
1309 then tm_file="$tm_file tm-dwarf2.h"
1312 # Say what files are being used for the output code and MD file.
1313 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1314 echo "Using \`$srcdir/config/$md_file' as machine description file."
1316 # If any of the xm_file variables contain nonexistent files, warn
1317 # about them and drop them.
1320 for x in $build_xm_file; do
1321 if test -f $srcdir/config/$x
1323 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1329 for x in $host_xm_file; do
1330 if test -f $srcdir/config/$x
1332 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1338 for x in $xm_file; do
1339 if test -f $srcdir/config/$x
1341 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1347 for f in $tm_file; do
1350 if test $count = ax; then
1351 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1353 echo "Using the following target machine macro files:"
1354 for f in $tm_file; do
1355 echo " $srcdir/config/$f"
1359 if test x$need_64bit_hwint = xyes; then
1360 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1361 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1364 if test x$use_long_long_for_widest_fast_int = xyes; then
1365 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1366 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1367 efficiently supported by the host hardware.])
1370 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1371 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1373 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1374 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1377 for f in $host_xm_file; do
1380 if test $count = a; then
1382 elif test $count = ax; then
1383 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1385 echo "Using the following host machine macro files:"
1386 for f in $host_xm_file; do
1387 echo " $srcdir/config/$f"
1390 echo "Using ${out_host_hook_obj} for host machine hooks."
1392 if test "$host_xm_file" != "$build_xm_file"; then
1394 for f in $build_xm_file; do
1397 if test $count = a; then
1399 elif test $count = ax; then
1400 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1402 echo "Using the following build machine macro files:"
1403 for f in $build_xm_file; do
1404 echo " $srcdir/config/$f"
1409 if test -n "$configured_native_system_header_dir"; then
1410 native_system_header_dir=$configured_native_system_header_dir
1412 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1413 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1417 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1418 gcc_cv_mcontext_underscores,
1420 #include <sys/cdefs.h>
1421 #include <sys/signal.h>
1422 #include <ucontext.h>
1423 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1425 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1426 if test $gcc_cv_mcontext_underscores = yes; then
1427 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1428 [mcontext_t fields start with __])
1437 # Check if a valid thread package
1438 case ${enable_threads} in
1441 target_thread_file='single'
1445 target_thread_file='single'
1447 aix | dce | lynx | mipssde | posix | rtems | \
1448 single | tpf | vxworks | win32)
1449 target_thread_file=${enable_threads}
1452 echo "${enable_threads} is an unknown thread package" 1>&2
1457 if test x${thread_file} = x; then
1458 # No thread file set by target-specific clauses in config.gcc,
1459 # so use file chosen by default logic above
1460 thread_file=${target_thread_file}
1468 if test x$enable___cxa_atexit = xyes || \
1469 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1470 if test x$host = x$target; then
1472 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1473 # keyed to flag_use_cxa_atexit
1481 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1482 [echo "__cxa_atexit can't be enabled on this target"])
1486 # We can't check for __cxa_atexit when building a cross, so assume
1490 if test x$use_cxa_atexit = xyes; then
1491 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1492 [Define if you want to use __cxa_atexit, rather than atexit, to
1493 register C++ destructors for local statics and global objects.
1494 This is essential for fully standards-compliant handling of
1495 destructors, but requires __cxa_atexit in libc.])
1499 # Look for a file containing extra machine modes.
1500 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1501 extra_modes_file='$(srcdir)'/config/${extra_modes}
1502 AC_SUBST(extra_modes_file)
1503 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1504 [Define to the name of a file containing a list of extra machine modes
1505 for this architecture.])
1508 # Convert extra_options into a form suitable for Makefile use.
1511 for f in $extra_options; do
1512 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1513 all_opt_files="$all_opt_files $srcdir/config/$f"
1515 AC_SUBST(extra_opt_files)
1517 # auto-host.h is the file containing items generated by autoconf and is
1518 # the first file included by config.h.
1519 # If host=build, it is correct to have bconfig include auto-host.h
1520 # as well. If host!=build, we are in error and need to do more
1521 # work to find out the build config parameters.
1522 if test x$host = x$build
1524 build_auto=auto-host.h
1526 # We create a subdir, then run autoconf in the subdir.
1527 # To prevent recursion we set host and build for the new
1528 # invocation of configure to the build for this invocation
1535 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1536 *) realsrcdir=../${srcdir};;
1538 # Clearing GMPINC is necessary to prevent host headers being
1539 # used by the build compiler. Defining GENERATOR_FILE stops
1540 # system.h from including gmp.h.
1541 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1542 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1543 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1544 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1545 ${realsrcdir}/configure \
1546 --enable-languages=${enable_languages-all} \
1547 --target=$target_alias --host=$build_alias --build=$build_alias
1549 # We just finished tests for the build machine, so rename
1550 # the file auto-build.h in the gcc directory.
1551 mv auto-host.h ../auto-build.h
1554 build_auto=auto-build.h
1556 AC_SUBST(build_subdir)
1558 tm_file="${tm_file} defaults.h"
1559 tm_p_file="${tm_p_file} tm-preds.h"
1560 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1561 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1562 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1563 # put this back in temporarily.
1564 xm_file="auto-host.h ansidecl.h ${xm_file}"
1571 # Compile in configure arguments.
1572 if test -f configargs.h ; then
1573 # Being re-configured.
1574 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1575 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1577 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1580 # Double all backslashes and backslash all quotes to turn
1581 # gcc_config_arguments into a C string.
1582 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1583 $gcc_config_arguments
1585 gcc_config_arguments_str=`cat conftest.out`
1588 cat > configargs.h <<EOF
1589 /* Generated automatically. */
1590 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1591 static const char thread_model[] = "$thread_file";
1593 static const struct {
1594 const char *name, *value;
1595 } configure_default_options[] = $configure_default_options;
1600 gcc_BASEVER=`cat $srcdir/BASE-VER`
1601 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1602 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1603 if test -f $srcdir/REVISION ; then
1604 gcc_REVISION=`cat $srcdir/REVISION`
1608 cat > plugin-version.h <<EOF
1609 #include "configargs.h"
1611 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1612 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1613 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1614 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1616 static char basever[] = "$gcc_BASEVER";
1617 static char datestamp[] = "$gcc_DATESTAMP";
1618 static char devphase[] = "$gcc_DEVPHASE";
1619 static char revision[] = "$gcc_REVISION";
1621 /* FIXME plugins: We should make the version information more precise.
1622 One way to do is to add a checksum. */
1624 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1626 configuration_arguments};
1630 # Internationalization
1631 ZW_GNU_GETTEXT_SISTER_DIR
1633 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1634 # -liconv on the link line twice.
1635 case "$LIBINTL" in *$LIBICONV*)
1639 AC_ARG_ENABLE(secureplt,
1640 [AS_HELP_STRING([--enable-secureplt],
1641 [enable -msecure-plt by default for PowerPC])],
1644 AC_ARG_ENABLE(leading-mingw64-underscores,
1645 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1646 [enable leading underscores on 64 bit mingw targets]),
1648 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1649 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1650 [Define if we should use leading underscore on 64 bit mingw targets])])
1653 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1656 AC_ARG_ENABLE(frame-pointer,
1657 [AS_HELP_STRING([--enable-frame-pointer],
1658 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1661 linux* | darwin[[8912]]*)
1662 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1664 enable_frame_pointer=no
1667 enable_frame_pointer=yes
1672 # Windows32 Registry support for specifying GCC installation paths.
1673 AC_ARG_ENABLE(win32-registry,
1674 [AS_HELP_STRING([--disable-win32-registry],
1675 [disable lookup of installation paths in the
1676 Registry on Windows hosts])
1677 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1678 AS_HELP_STRING([--enable-win32-registry=KEY],
1679 [use KEY instead of GCC version as the last portion
1680 of the registry key])],,)
1683 win32 | pe | cygwin* | mingw32* | uwin*)
1684 if test "x$enable_win32_registry" != xno; then
1685 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1688 if test "x$enable_win32_registry" != xno; then
1689 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1690 [Define to 1 if installation paths should be looked up in the Windows
1691 Registry. Ignored on non-Windows hosts.])
1693 if test "x$enable_win32_registry" != xyes \
1694 && test "x$enable_win32_registry" != x; then
1695 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1696 [Define to be the last component of the Windows registry key under which
1697 to look for installation paths. The full key used will be
1698 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1699 The default is the GCC version number.])
1705 # Get an absolute path to the GCC top-level source directory
1706 holddir=`${PWDCMD-pwd}`
1708 topdir=`${PWDCMD-pwd}`
1711 # Conditionalize the makefile for this host machine.
1713 for f in ${host_xmake_file}
1715 if test -f ${srcdir}/config/$f
1717 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1721 # Conditionalize the makefile for this target machine.
1723 for f in ${tmake_file}
1725 if test -f ${srcdir}/config/$f
1727 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1730 tmake_file="${tmake_file_}"
1732 out_object_file=`basename $out_file .c`.o
1733 common_out_object_file=`basename $common_out_file .c`.o
1735 tm_file_list="options.h"
1736 tm_include_list="options.h insn-constants.h"
1737 for f in $tm_file; do
1740 f=`echo $f | sed 's/^..//'`
1741 tm_file_list="${tm_file_list} $f"
1742 tm_include_list="${tm_include_list} $f"
1745 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1746 tm_include_list="${tm_include_list} $f"
1749 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1750 tm_include_list="${tm_include_list} config/$f"
1757 for f in $tm_p_file; do
1760 tm_p_file_list="${tm_p_file_list} $f"
1761 tm_p_include_list="${tm_p_include_list} $f"
1764 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1765 tm_p_include_list="${tm_p_include_list} config/$f"
1771 for f in $xm_file; do
1774 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1775 xm_include_list="${xm_include_list} $f"
1778 xm_file_list="${xm_file_list} $f"
1779 xm_include_list="${xm_include_list} $f"
1782 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1783 xm_include_list="${xm_include_list} config/$f"
1789 host_xm_include_list=
1790 for f in $host_xm_file; do
1793 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1794 host_xm_include_list="${host_xm_include_list} $f"
1797 host_xm_file_list="${host_xm_file_list} $f"
1798 host_xm_include_list="${host_xm_include_list} $f"
1801 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1802 host_xm_include_list="${host_xm_include_list} config/$f"
1808 for f in $build_xm_file; do
1811 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1812 build_xm_include_list="${build_xm_include_list} $f"
1814 auto-build.h | auto-host.h )
1815 build_xm_file_list="${build_xm_file_list} $f"
1816 build_xm_include_list="${build_xm_include_list} $f"
1819 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1820 build_xm_include_list="${build_xm_include_list} config/$f"
1825 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1826 # cross-compiler which does not use the native headers and libraries.
1827 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1828 CROSS= AC_SUBST(CROSS)
1829 ALL=all.internal AC_SUBST(ALL)
1830 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1832 if test "x$with_build_sysroot" != x; then
1833 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1835 # This value is used, even on a native system, because
1836 # CROSS_SYSTEM_HEADER_DIR is just
1837 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1838 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1841 if test x$host != x$target
1843 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1845 SYSTEM_HEADER_DIR=$build_system_header_dir
1846 case "$host","$target" in
1847 # Darwin crosses can use the host system's libraries and headers,
1848 # because of the fat library support. Of course, it must be the
1849 # same version of Darwin on both sides. Allow the user to
1850 # just say --target=foo-darwin without a version number to mean
1851 # "the version on this system".
1852 *-*-darwin*,*-*-darwin*)
1853 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1854 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1855 if test $hostos = $targetos -o $targetos = darwin ; then
1857 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1862 i?86-*-*,x86_64-*-* \
1863 | powerpc*-*-*,powerpc64*-*-*)
1864 CROSS="$CROSS -DNATIVE_CROSS" ;;
1869 if test "x$with_headers" = x; then
1876 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1877 SYSTEM_HEADER_DIR=$build_system_header_dir
1880 # If this is a cross-compiler that does not
1881 # have its own set of headers then define
1884 # If this is using newlib, without having the headers available now,
1885 # then define inhibit_libc in LIBGCC2_CFLAGS.
1886 # This prevents libgcc2 from containing any code which requires libc
1888 : ${inhibit_libc=false}
1889 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1890 test x$with_newlib = xyes ; } &&
1891 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1894 AC_SUBST(inhibit_libc)
1896 # When building gcc with a cross-compiler, we need to adjust things so
1897 # that the generator programs are still built with the native compiler.
1898 # Also, we cannot run fixincludes.
1900 # These are the normal (build=host) settings:
1901 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1902 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1903 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1904 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1905 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1906 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1908 # And these apply if build != host, or we are generating coverage data
1909 if test x$build != x$host || test "x$coverage_flags" != x
1911 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1912 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1913 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1916 # Expand extra_headers to include complete path.
1917 # This substitutes for lots of t-* files.
1919 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1920 for file in ${extra_headers} ; do
1921 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1924 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1925 if test x"$use_gcc_tgmath" = xyes
1926 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1929 # Define collect2 in Makefile.
1930 case $host_can_use_collect2 in
1932 *) collect2='collect2$(exeext)' ;;
1934 AC_SUBST([collect2])
1936 # Add a definition of USE_COLLECT2 if system wants one.
1937 case $use_collect2 in
1938 no) use_collect2= ;;
1941 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1942 xm_defines="${xm_defines} USE_COLLECT2"
1943 case $host_can_use_collect2 in
1945 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1951 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1952 [Define to the name of the LTO plugin DSO that must be
1953 passed to the linker's -plugin=LIB option.])
1955 # ---------------------------
1956 # Assembler & linker features
1957 # ---------------------------
1959 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1960 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1961 # However when ld-new is first executed from the build tree, libtool will
1962 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1963 # to the build tree. While doing this we need to use the previous-stage
1964 # linker, or we have an infinite loop. The presence of a shell script as
1965 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1966 # the gcc/collect-ld script. So we need to know how libtool works, or
1967 # exec-tool will fail.
1969 m4_defun([_LT_CONFIG_COMMANDS], [])
1972 AC_SUBST(enable_fast_install)
1974 # Identify the assembler which will work hand-in-glove with the newly
1975 # built GCC, so that we can examine its features. This is the assembler
1976 # which will be driven by the driver program.
1978 # If build != host, and we aren't building gas in-tree, we identify a
1979 # build->target assembler and hope that it will have the same features
1980 # as the host->target assembler we'll be using.
1981 gcc_cv_gas_major_version=
1982 gcc_cv_gas_minor_version=
1983 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1985 m4_pattern_allow([AS_FOR_TARGET])dnl
1986 AS_VAR_SET_IF(gcc_cv_as,, [
1987 if test -x "$DEFAULT_ASSEMBLER"; then
1988 gcc_cv_as="$DEFAULT_ASSEMBLER"
1989 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1990 && test -f ../gas/Makefile \
1991 && test x$build = x$host; then
1992 gcc_cv_as=../gas/as-new$build_exeext
1993 elif test -x as$build_exeext; then
1994 # Build using assembler in the current directory.
1995 gcc_cv_as=./as$build_exeext
1996 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
1997 gcc_cv_as="$AS_FOR_TARGET"
1999 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2002 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2003 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2004 case "$ORIGINAL_AS_FOR_TARGET" in
2005 ./as | ./as$build_exeext) ;;
2006 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2009 AC_MSG_CHECKING(what assembler to use)
2010 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2011 # Single tree build which includes gas. We want to prefer it
2012 # over whatever linker top-level may have detected, since
2013 # we'll use what we're building after installation anyway.
2014 AC_MSG_RESULT(newly built gas)
2016 _gcc_COMPUTE_GAS_VERSION
2017 in_tree_gas_is_elf=no
2018 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2019 || (grep 'obj_format = multi' ../gas/Makefile \
2020 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2022 in_tree_gas_is_elf=yes
2025 AC_MSG_RESULT($gcc_cv_as)
2031 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2032 [case "${enableval}" in
2039 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2040 [case "${enableval}" in
2042 install_gold_as_default=yes
2045 if test x${default_ld} != x; then
2046 install_gold_as_default=yes
2052 AC_MSG_ERROR([invalid --enable-gold argument])
2055 [install_gold_as_default=no])
2057 # Identify the linker which will work hand-in-glove with the newly
2058 # built GCC, so that we can examine its features. This is the linker
2059 # which will be driven by the driver program.
2061 # If build != host, and we aren't building gas in-tree, we identify a
2062 # build->target linker and hope that it will have the same features
2063 # as the host->target linker we'll be using.
2064 gcc_cv_gld_major_version=
2065 gcc_cv_gld_minor_version=
2066 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2067 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2068 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2070 AS_VAR_SET_IF(gcc_cv_ld,, [
2071 if test -x "$DEFAULT_LINKER"; then
2072 gcc_cv_ld="$DEFAULT_LINKER"
2073 elif test $install_gold_as_default = yes \
2074 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2075 && test -f ../gold/Makefile \
2076 && test x$build = x$host; then
2077 gcc_cv_ld=../gold/ld-new$build_exeext
2078 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2079 && test -f ../ld/Makefile \
2080 && test x$build = x$host; then
2081 gcc_cv_ld=../ld/ld-new$build_exeext
2082 elif test -x collect-ld$build_exeext; then
2083 # Build using linker in the current directory.
2084 gcc_cv_ld=./collect-ld$build_exeext
2085 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2086 gcc_cv_ld="$LD_FOR_TARGET"
2088 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2091 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2092 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2093 # if the PLUGIN_LD is set ld-new, just have it as ld
2094 # as that is the installed named.
2095 if test x$PLUGIN_LD_SUFFIX = xld-new \
2096 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2099 AC_ARG_WITH(plugin-ld,
2100 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2101 [if test x"$withval" != x; then
2102 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2103 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2105 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2106 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2108 # Check to see if we are using gold instead of ld
2109 AC_MSG_CHECKING(whether we are using gold)
2111 if test x$gcc_cv_ld != x; then
2112 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2113 | grep "GNU gold" > /dev/null; then
2117 AC_MSG_RESULT($ld_is_gold)
2119 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2120 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2121 case "$ORIGINAL_LD_FOR_TARGET" in
2122 ./collect-ld | ./collect-ld$build_exeext) ;;
2123 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2126 AC_MSG_CHECKING(what linker to use)
2127 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2128 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2129 # Single tree build which includes ld. We want to prefer it
2130 # over whatever linker top-level may have detected, since
2131 # we'll use what we're building after installation anyway.
2132 AC_MSG_RESULT(newly built ld)
2134 in_tree_ld_is_elf=no
2135 if (grep 'EMUL = .*elf' ../ld/Makefile \
2136 || grep 'EMUL = .*linux' ../ld/Makefile \
2137 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2138 in_tree_ld_is_elf=yes
2139 elif test "$ld_is_gold" = yes; then
2140 in_tree_ld_is_elf=yes
2142 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
2145 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2146 if test x$gcc_cv_gld_version != x; then
2150 case $gcc_cv_gld_version in
2153 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2156 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2157 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2159 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2160 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2162 AC_MSG_RESULT($gcc_cv_ld)
2164 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2165 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2166 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2169 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2170 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2172 # Figure out what nm we will be using.
2173 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2174 AS_VAR_SET_IF(gcc_cv_nm,, [
2175 if test -f $gcc_cv_binutils_srcdir/configure.in \
2176 && test -f ../binutils/Makefile \
2177 && test x$build = x$host; then
2178 gcc_cv_nm=../binutils/nm-new$build_exeext
2179 elif test -x nm$build_exeext; then
2180 gcc_cv_nm=./nm$build_exeext
2181 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2182 gcc_cv_nm="$NM_FOR_TARGET"
2184 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2187 AC_MSG_CHECKING(what nm to use)
2188 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2189 # Single tree build which includes binutils.
2190 AC_MSG_RESULT(newly built nm)
2193 AC_MSG_RESULT($gcc_cv_nm)
2197 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2198 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2199 case "$ORIGINAL_NM_FOR_TARGET" in
2200 ./nm | ./nm$build_exeext) ;;
2201 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2205 # Figure out what objdump we will be using.
2206 AS_VAR_SET_IF(gcc_cv_objdump,, [
2207 if test -f $gcc_cv_binutils_srcdir/configure.in \
2208 && test -f ../binutils/Makefile \
2209 && test x$build = x$host; then
2210 # Single tree build which includes binutils.
2211 gcc_cv_objdump=../binutils/objdump$build_exeext
2212 elif test -x objdump$build_exeext; then
2213 gcc_cv_objdump=./objdump$build_exeext
2214 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2215 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2217 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2220 AC_MSG_CHECKING(what objdump to use)
2221 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2222 # Single tree build which includes binutils.
2223 AC_MSG_RESULT(newly built objdump)
2224 elif test x$gcc_cv_objdump = x; then
2225 AC_MSG_RESULT(not found)
2227 AC_MSG_RESULT($gcc_cv_objdump)
2230 # Figure out what readelf we will be using.
2231 AS_VAR_SET_IF(gcc_cv_readelf,, [
2232 if test -f $gcc_cv_binutils_srcdir/configure.in \
2233 && test -f ../binutils/Makefile \
2234 && test x$build = x$host; then
2235 # Single tree build which includes binutils.
2236 gcc_cv_readelf=../binutils/readelf$build_exeext
2237 elif test -x readelf$build_exeext; then
2238 gcc_cv_readelf=./readelf$build_exeext
2240 AC_PATH_PROG(gcc_cv_readelf, readelf)
2243 AC_MSG_CHECKING(what readelf to use)
2244 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2245 # Single tree build which includes binutils.
2246 AC_MSG_RESULT(newly built readelf)
2247 elif test x$gcc_cv_readelf = x; then
2248 AC_MSG_RESULT(not found)
2250 AC_MSG_RESULT($gcc_cv_readelf)
2253 # Figure out what assembler alignment features are present.
2254 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2258 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2259 [Define if your assembler supports .balign and .p2align.])])
2261 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2264 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2265 [Define if your assembler supports specifying the maximum number
2266 of bytes to skip when using the GAS .p2align command.])])
2268 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2271 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2272 [Define if your assembler supports .literal16.])])
2274 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2276 [conftest_label1: .word 0
2278 conftest_label2: .word 0
2280 [if test x$gcc_cv_nm != x; then
2281 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2282 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2283 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2285 else gcc_cv_as_subsection_m1=yes
2287 rm -f conftest.nm1 conftest.nm2
2289 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2290 [Define if your assembler supports .subsection and .subsection -1 starts
2291 emitting at the beginning of your section.])])
2293 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2296 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2298 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2300 [ .weakref foobar, barfnot],,
2301 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2303 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2306 .NSUBSPA $CODE$,COMDAT],,
2307 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2309 # .hidden needs to be supported in both the assembler and the linker,
2310 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2311 # This is irritatingly difficult to feature test for; we have to check the
2312 # date string after the version number. If we've got an in-tree
2313 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2315 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2316 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2320 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2321 # STV_HIDDEN, so disable .hidden support if so.
2323 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2324 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2325 cat > conftest.s <<EOF
2332 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2333 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2334 grep '\.hidden default' > /dev/null; then
2337 gcc_cv_as_hidden=yes
2340 # Assume bug is present if objdump is missing.
2345 gcc_cv_as_hidden=yes
2350 # Darwin as has some visibility support, though with a different syntax.
2351 gcc_cv_as_hidden=yes
2355 # gnu_indirect_function type is an extension proposed at
2356 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2357 # selection of function implementation
2358 AC_ARG_ENABLE(gnu-indirect-function,
2359 [AS_HELP_STRING([--enable-gnu-indirect-function],
2360 [enable the use of the @gnu_indirect_function to glibc systems])],
2361 [case $enable_gnu_indirect_function in
2363 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2364 Valid choices are 'yes' and 'no'.]) ;;
2366 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2368 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2369 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2370 [Define if your system supports gnu indirect functions.])
2374 if test $in_tree_ld != yes ; then
2375 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2376 if echo "$ld_ver" | grep GNU > /dev/null; then
2377 if test x"$ld_is_gold" = xyes; then
2378 # GNU gold --version looks like this:
2380 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2382 # We extract the binutils version which is more familiar and specific
2383 # than the gold version.
2384 ld_vers=`echo $ld_ver | sed -n \
2385 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2387 # GNU ld --version looks like this:
2389 # GNU ld (GNU Binutils) 2.21.51.20110225
2390 ld_vers=`echo $ld_ver | sed -n \
2391 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2393 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'`
2394 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2395 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2396 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2400 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2403 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2404 # /usr/ccs/bin/ld has been configured.
2405 ld_ver=`$gcc_cv_ld -V 2>&1`
2406 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2407 ld_vers=`echo $ld_ver | sed -n \
2408 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2409 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2410 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2418 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2419 [[if test $in_tree_ld = yes ; then
2421 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 \
2422 && test $in_tree_ld_is_elf = yes; then
2423 gcc_cv_ld_hidden=yes
2426 gcc_cv_ld_hidden=yes
2427 if test x"$ld_is_gold" = xyes; then
2429 elif echo "$ld_ver" | grep GNU > /dev/null; then
2431 mmix-knuth-mmixware)
2432 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2436 if test 0"$ld_date" -lt 20020404; then
2437 if test -n "$ld_date"; then
2438 # If there was date string, but was earlier than 2002-04-04, fail
2440 elif test -z "$ld_vers"; then
2441 # If there was no date string nor ld version number, something is wrong
2444 test -z "$ld_vers_patch" && ld_vers_patch=0
2445 if test "$ld_vers_major" -lt 2; then
2447 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2448 gcc_cv_ld_hidden="no"
2449 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2457 # Darwin ld has some visibility support.
2458 gcc_cv_ld_hidden=yes
2460 hppa64*-*-hpux* | ia64*-*-hpux*)
2461 gcc_cv_ld_hidden=yes
2463 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2464 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2465 # .symbolic was only added in Solaris 9 12/02.
2466 gcc_cv_ld_hidden=yes
2474 libgcc_visibility=no
2475 AC_SUBST(libgcc_visibility)
2476 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2477 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2478 libgcc_visibility=yes
2479 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2480 [Define if your assembler and linker support .hidden.])
2483 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2484 gcc_cv_ld_ro_rw_mix=unknown
2485 if test $in_tree_ld = yes ; then
2486 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 \
2487 && test $in_tree_ld_is_elf = yes; then
2488 gcc_cv_ld_ro_rw_mix=read-write
2490 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2491 echo '.section myfoosect, "a"' > conftest1.s
2492 echo '.section myfoosect, "aw"' > conftest2.s
2493 echo '.byte 1' >> conftest2.s
2494 echo '.section myfoosect, "a"' > conftest3.s
2495 echo '.byte 0' >> conftest3.s
2496 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2497 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2498 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2499 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2500 conftest2.o conftest3.o > /dev/null 2>&1; then
2501 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2502 | sed -e '/myfoosect/!d' -e N`
2503 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2504 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2505 gcc_cv_ld_ro_rw_mix=read-only
2507 gcc_cv_ld_ro_rw_mix=read-write
2512 rm -f conftest.* conftest[123].*
2515 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2516 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2517 [Define if your linker links a mix of read-only
2518 and read-write sections into a read-write section.])
2520 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2522 gcc_AC_INITFINI_ARRAY
2524 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2525 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2533 [[# GAS versions before 2.11 do not support uleb128,
2534 # despite appearing to.
2535 # ??? There exists an elf-specific test that will crash
2536 # the assembler. Perhaps it's better to figure out whether
2537 # arbitrary sections are supported and try the test.
2538 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2539 if echo "$as_ver" | grep GNU > /dev/null; then
2540 as_vers=`echo $as_ver | sed -n \
2541 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2542 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2543 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2544 if test $as_major -eq 2 && test $as_minor -lt 11
2546 else gcc_cv_as_leb128=yes
2549 [AC_DEFINE(HAVE_AS_LEB128, 1,
2550 [Define if your assembler supports .sleb128 and .uleb128.])])
2552 # Check if we have assembler support for unwind directives.
2553 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2560 .cfi_escape 1, 2, 3, 4, 5
2564 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2565 # read-only and read-write sections, we need to make sure that the
2566 # assembler used emits read-write .eh_frame sections.
2567 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2568 if test "x$gcc_cv_objdump" != x; then
2569 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2570 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2571 gcc_cv_as_cfi_directive=no
2574 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2575 # On Solaris/x86, make sure that GCC and gas agree on using
2576 # read-only .eh_frame sections for 64-bit.
2577 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2578 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2579 sed -e /.eh_frame/!d -e N | \
2580 grep READONLY > /dev/null; then
2581 gcc_cv_as_cfi_directive=yes
2583 gcc_cv_as_cfi_directive=no
2587 gcc_cv_as_cfi_directive=yes
2592 # no objdump, err on the side of caution
2593 gcc_cv_as_cfi_directive=no
2596 gcc_cv_as_cfi_directive=yes
2600 gcc_cv_as_cfi_directive=yes
2603 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2604 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2608 .cfi_adjust_cfa_offset 64
2610 .cfi_adjust_cfa_offset 128
2613 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2614 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2615 gcc_cv_as_cfi_advance_working=yes
2619 # no objdump, err on the side of caution
2620 gcc_cv_as_cfi_advance_working=no
2622 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2623 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2624 [`if test $gcc_cv_as_cfi_directive = yes \
2625 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2626 [Define 0/1 if your assembler supports CFI directives.])
2628 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2629 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2630 gcc_cv_as_cfi_personality_directive, ,,
2633 .cfi_personality 0, symbol
2635 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2636 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2637 then echo 1; else echo 0; fi`],
2638 [Define 0/1 if your assembler supports .cfi_personality.])
2640 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2641 gcc_cv_as_cfi_sections_directive, ,,
2643 .cfi_sections .debug_frame, .eh_frame
2647 win32 | pe | cygwin* | mingw32* | uwin*)
2648 # Need to check that we generated the correct relocation for the
2649 # .debug_frame section. This was fixed for binutils 2.21.
2650 gcc_cv_as_cfi_sections_directive=no
2651 if test "x$gcc_cv_objdump" != x; then
2652 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2653 grep secrel > /dev/null; then
2654 gcc_cv_as_cfi_sections_directive=yes
2659 gcc_cv_as_cfi_sections_directive=yes
2662 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2663 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2664 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2665 then echo 1; else echo 0; fi`],
2666 [Define 0/1 if your assembler supports .cfi_sections.])
2668 # GAS versions up to and including 2.11.0 may mis-optimize
2670 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2678 .section .eh_frame,"aw",@progbits
2680 .4byte .LECIE1-.LSCIE1
2694 .4byte .LEFDE1-.LASFDE1
2696 .4byte .LASFDE1-__FRAME_BEGIN__
2704 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2705 cat > conftest.lit <<EOF
2706 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2707 0010 01000000 12000000 18000000 00000000 ................
2708 0020 08000000 04080000 0044 .........D @&t@
2710 cat > conftest.big <<EOF
2711 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2712 0010 00000001 00000012 00000018 00000000 ................
2713 0020 00000008 04000000 0844 .........D @&t@
2715 # If the assembler didn't choke, and we can objdump,
2716 # and we got the correct data, then succeed.
2717 # The text in the here-document typically retains its unix-style line
2718 # endings, while the output of objdump will use host line endings.
2719 # Therefore, use diff -b for the comparisons.
2720 if test x$gcc_cv_objdump != x \
2721 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2722 | tail -3 > conftest.got \
2723 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2724 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2726 gcc_cv_as_eh_frame=yes
2727 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2728 gcc_cv_as_eh_frame=buggy
2730 # Uh oh, what do we do now?
2731 gcc_cv_as_eh_frame=no
2734 if test $gcc_cv_as_eh_frame = buggy; then
2735 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2736 [Define if your assembler mis-optimizes .eh_frame data.])
2739 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2740 [elf,2,12,0], [--fatal-warnings],
2741 [.section .rodata.str, "aMS", @progbits, 1])
2742 if test $gcc_cv_as_shf_merge = no; then
2743 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2744 [elf,2,12,0], [--fatal-warnings],
2745 [.section .rodata.str, "aMS", %progbits, 1])
2747 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2748 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2749 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2751 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2752 gcc_cv_as_comdat_group,
2753 [elf,2,16,0], [--fatal-warnings],
2754 [.section .text,"axG",@progbits,.foo,comdat])
2755 if test $gcc_cv_as_comdat_group = yes; then
2756 gcc_cv_as_comdat_group_percent=no
2757 gcc_cv_as_comdat_group_group=no
2759 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2760 gcc_cv_as_comdat_group_percent,
2761 [elf,2,16,0], [--fatal-warnings],
2762 [.section .text,"axG",%progbits,.foo,comdat])
2763 if test $gcc_cv_as_comdat_group_percent = yes; then
2764 gcc_cv_as_comdat_group_group=no
2766 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2767 gcc_cv_as_comdat_group_group=no
2770 # Sun as uses a completely different syntax.
2775 .group foo,".text%foo",#comdat
2776 .section ".text%foo", #alloc,#execinstr,#progbits
2781 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2783 .group foo,.text%foo,#comdat
2784 .section .text%foo, "ax", @progbits
2790 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2791 gcc_cv_as_comdat_group_group,
2797 if test x"$ld_is_gold" = xyes; then
2799 elif test $in_tree_ld = yes ; then
2801 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 \
2802 && test $in_tree_ld_is_elf = yes; then
2805 elif echo "$ld_ver" | grep GNU > /dev/null; then
2807 if test 0"$ld_date" -lt 20050308; then
2808 if test -n "$ld_date"; then
2809 # If there was date string, but was earlier than 2005-03-08, fail
2811 elif test "$ld_vers_major" -lt 2; then
2813 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2820 *-*-solaris2.1[1-9]*)
2822 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2823 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2826 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2827 # least ld version 1.2267.
2828 if test "$ld_vers_major" -gt 1; then
2830 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2832 elif test "$ld_vers_minor" -ge 2267; then
2837 # Assume linkers other than GNU ld don't support COMDAT group.
2843 # Allow overriding the automatic COMDAT group tests above.
2844 AC_ARG_ENABLE(comdat,
2845 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2846 [comdat_group="$enable_comdat"])
2847 if test $comdat_group = no; then
2848 gcc_cv_as_comdat_group=no
2849 gcc_cv_as_comdat_group_percent=no
2850 gcc_cv_as_comdat_group_group=no
2852 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2853 [`if test $gcc_cv_as_comdat_group = yes \
2854 || test $gcc_cv_as_comdat_group_percent = yes \
2855 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2856 [Define 0/1 if your assembler and linker support COMDAT groups.])
2858 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2859 gcc_cv_as_discriminator,
2863 .loc 1 1 0 discriminator 1],,
2864 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2865 [Define if your assembler supports the .loc discriminator sub-directive.])])
2867 # Thread-local storage - the check is heavily parameterized.
2876 .section ".tdata","awT",@progbits
2879 ldq $27,__tls_get_addr($29) !literal!1
2880 lda $16,foo($29) !tlsgd!1
2881 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2882 ldq $27,__tls_get_addr($29) !literal!2
2883 lda $16,foo($29) !tlsldm!2
2884 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2885 ldq $1,foo($29) !gotdtprel
2886 ldah $2,foo($29) !dtprelhi
2887 lda $3,foo($2) !dtprello
2888 lda $4,foo($29) !dtprel
2889 ldq $1,foo($29) !gottprel
2890 ldah $2,foo($29) !tprelhi
2891 lda $3,foo($2) !tprello
2892 lda $4,foo($29) !tprel'
2895 tls_as_opt=--fatal-warnings
2897 cris-*-*|crisv32-*-*)
2899 .section ".tdata","awT",@progbits
2906 tls_as_opt=--fatal-warnings
2910 .section ".tdata","awT",@progbits
2922 .section ".tdata","awT",@progbits
2926 addil LT%foo-$tls_gdidx$,gp
2927 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2930 addil LT%foo-$tls_ldidx$,gp
2932 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2933 addil LR%foo-$tls_dtpoff$,%ret0
2934 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2936 addil LT%foo-$tls_ieoff$,gp
2937 ldw RT%foo-$tls_ieoff$(%r1),%t2
2940 addil LR%foo-$tls_leoff$,%t1
2941 ldo RR%foo-$tls_leoff$(%r1),%t2'
2944 tls_as_opt=--fatal-warnings
2948 .section ".tdata","awT",%progbits
2959 i[34567]86-*-* | x86_64-*-*)
2961 i[34567]86-*-solaris2.*)
2963 tga_func=___tls_get_addr
2965 x86_64-*-solaris2.1[0-9]*)
2967 tga_func=__tls_get_addr
2973 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2975 .section .tdata,"awt",@progbits'
2980 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
2981 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
2985 .section ".tdata","awT",@progbits'
2989 tls_as_opt="--fatal-warnings"
2993 conftest_s="$conftest_s
2997 leal foo@tlsgd(,%ebx,1), %eax
2998 leal foo@tlsldm(%ebx), %eax
2999 leal foo@dtpoff(%eax), %edx
3000 movl foo@gottpoff(%ebx), %eax
3001 subl foo@gottpoff(%ebx), %eax
3002 addl foo@gotntpoff(%ebx), %eax
3003 movl foo@indntpoff, %eax
3004 movl \$foo@tpoff, %eax
3005 subl \$foo@tpoff, %eax
3006 leal foo@ntpoff(%ecx), %eax"
3009 if test x$on_solaris = xyes; then
3011 yes) tls_as_opt="$tls_as_opt --64" ;;
3012 no) tls_as_opt="$tls_as_opt -xarch=amd64" ;;
3015 conftest_s="$conftest_s
3019 leaq foo@tlsgd(%rip), %rdi
3020 leaq foo@tlsld(%rip), %rdi
3021 leaq foo@dtpoff(%rax), %rdx
3022 movq foo@gottpoff(%rip), %rax
3023 movq \$foo@tpoff, %rax"
3029 .section ".tdata","awT",@progbits
3032 addl r16 = @ltoff(@dtpmod(foo#)), gp
3033 addl r17 = @ltoff(@dtprel(foo#)), gp
3034 addl r18 = @ltoff(@tprel(foo#)), gp
3035 addl r19 = @dtprel(foo#), gp
3036 adds r21 = @dtprel(foo#), r13
3037 movl r23 = @dtprel(foo#)
3038 addl r20 = @tprel(foo#), gp
3039 adds r22 = @tprel(foo#), r13
3040 movl r24 = @tprel(foo#)'
3043 tls_as_opt=--fatal-warnings
3047 .section .tdata,"awT",@progbits
3051 addik r5,r20,x@TLSGD
3052 addik r5,r20,x@TLSLDM'
3055 tls_as_opt='--fatal-warnings'
3059 .section .tdata,"awT",@progbits
3063 addiu $4, $28, %tlsgd(x)
3064 addiu $4, $28, %tlsldm(x)
3065 lui $4, %dtprel_hi(x)
3066 addiu $4, $4, %dtprel_lo(x)
3067 lw $4, %gottprel(x)($28)
3068 lui $4, %tprel_hi(x)
3069 addiu $4, $4, %tprel_lo(x)'
3072 tls_as_opt='-32 --fatal-warnings'
3076 .section .tdata,"awT",@progbits
3081 move.l x@TLSGD(%a5),%a0
3082 move.l x@TLSLDM(%a5),%a0
3083 move.l x@TLSLDO(%a5),%a0
3084 move.l x@TLSIE(%a5),%a0
3085 move.l x@TLSLE(%a5),%a0'
3088 tls_as_opt='--fatal-warnings'
3092 .section ".tdata","awT",@progbits'
3095 tls_as_opt="--fatal-warnings"
3099 .section ".tdata","awT",%progbits
3103 add x0, x0, #:tlsgd_lo12:x
3108 tls_as_opt='--fatal-warnings'
3112 .extern __get_tpointer
3130 .section ".tdata","awT",@progbits
3138 addi 3,2,ld0@got@tlsgd
3144 addi 3,2,x1@got@tlsld
3150 addis 9,3,x2@dtprel@ha
3151 addi 9,9,x2@dtprel@l
3154 ld 9,x3@got@dtprel(2)
3160 tls_as_opt="-a64 --fatal-warnings"
3164 .section ".tdata","awT",@progbits
3172 addi 3,31,ld0@got@tlsgd
3174 addi 3,31,x1@got@tlsld
3177 addis 9,3,x2@dtprel@ha
3178 addi 9,9,x2@dtprel@l
3179 lwz 9,x3@got@tprel(31)
3182 addis 9,2,x2@tprel@ha
3183 addi 9,9,x2@tprel@l'
3186 tls_as_opt="-a32 --fatal-warnings"
3190 .section ".tdata","awT",@progbits
3199 l %r1,foo@GOTNTPOFF(%r12)
3200 l %r1,0(%r1):tls_load:foo
3201 bas %r14,0(%r1,%r13):tls_gdcall:foo
3202 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3205 tls_as_opt="-m31 --fatal-warnings"
3209 .section ".tdata","awT",@progbits
3217 lg %r1,foo@GOTNTPOFF(%r12)
3218 larl %r1,foo@INDNTPOFF
3219 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3220 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3223 tls_as_opt="-m64 -Aesame --fatal-warnings"
3225 sh-*-* | sh[34]-*-*)
3227 .section ".tdata","awT",@progbits
3237 tls_as_opt=--fatal-warnings
3241 sparc*-sun-solaris2.*)
3243 tga_func=__tls_get_addr
3249 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3251 .section ".tdata",#alloc,#write,#tls'
3256 .section ".tdata","awT",@progbits'
3259 tls_as_opt="-32 --fatal-warnings"
3261 conftest_s="$conftest_s
3264 sethi %tgd_hi22(foo), %o0
3265 add %o0, %tgd_lo10(foo), %o1
3266 add %l7, %o1, %o0, %tgd_add(foo)
3267 call __tls_get_addr, %tgd_call(foo)
3268 sethi %tldm_hi22(foo), %l1
3269 add %l1, %tldm_lo10(foo), %l2
3270 add %l7, %l2, %o0, %tldm_add(foo)
3271 call __tls_get_addr, %tldm_call(foo)
3272 sethi %tldo_hix22(foo), %l3
3273 xor %l3, %tldo_lox10(foo), %l4
3274 add %o0, %l4, %l5, %tldo_add(foo)
3275 sethi %tie_hi22(foo), %o3
3276 add %o3, %tie_lo10(foo), %o3
3277 ld [%l7 + %o3], %o2, %tie_ld(foo)
3278 add %g7, %o2, %o4, %tie_add(foo)
3279 sethi %tle_hix22(foo), %l1
3280 xor %l1, %tle_lox10(foo), %o5
3281 ld [%g7 + %o5], %o1"
3285 .section ".tdata","awT",@progbits
3288 addli r0, zero, tls_gd(foo)
3289 auli r0, zero, tls_gd_ha16(foo)
3290 addli r0, r0, tls_gd_lo16(foo)
3292 addli r0, zero, tls_ie(foo)
3293 auli r0, r0, tls_ie_ha16(foo)
3294 addli r0, r0, tls_ie_lo16(foo)'
3297 tls_as_opt="--fatal-warnings"
3301 .section ".tdata","awT",@progbits
3304 shl16insli r0, zero, hw0_last_tls_gd(foo)
3305 shl16insli r0, zero, hw1_last_tls_gd(foo)
3306 shl16insli r0, r0, hw0_tls_gd(foo)
3308 shl16insli r0, zero, hw1_last_tls_ie(foo)
3309 shl16insli r0, r0, hw0_tls_ie(foo)'
3312 tls_as_opt="--fatal-warnings"
3316 .section ".tdata","awT",@progbits
3319 movi a8, foo@TLSFUNC
3320 movi a10, foo@TLSARG
3321 callx8.tls a8, foo@TLSCALL'
3328 if test "x$enable_tls" = xno ; then
3329 : # TLS explicitly disabled.
3330 elif test "x$enable_tls" = xyes ; then
3331 set_have_as_tls=yes # TLS explicitly enabled.
3332 elif test -z "$tls_first_major"; then
3333 : # If we don't have a check, assume no support.
3335 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3336 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3337 [set_have_as_tls=yes])
3340 # TLS was introduced in the Solaris 9 FCS release. Support for GNU-style
3341 # TLS on x86 was only introduced in Solaris 9 4/04, replacing the earlier
3342 # Sun style that Sun ld and GCC don't support any longer.
3344 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3346 # Check ld and ld.so.1 TLS support.
3347 if echo "$ld_ver" | grep GNU > /dev/null; then
3348 # Assume all interesting versions of GNU ld have TLS support.
3349 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3353 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3355 min_tls_ld_vers_minor=374
3357 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3358 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3359 min_tls_ld_vers_minor=343
3362 if test "$ld_vers_major" -gt 1 || \
3363 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3369 AC_MSG_RESULT($ld_tls_support)
3372 save_LDFLAGS="$LDFLAGS"
3376 AC_MSG_CHECKING(library containing $tga_func)
3377 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3378 # (32-bit x86) only lived in libthread, so check for that. Keep
3379 # set_have_as_tls if found, disable if not.
3380 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3382 # Clear LIBS if we cannot support TLS.
3383 if test $set_have_as_tls = no; then
3386 # Always define LIB_TLS_SPEC, even without TLS support.
3387 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3388 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3389 AC_MSG_RESULT($LIBS)
3392 LDFLAGS="$save_LDFLAGS"
3395 if test $set_have_as_tls = yes ; then
3396 AC_DEFINE(HAVE_AS_TLS, 1,
3397 [Define if your assembler and linker support thread-local storage.])
3400 # Target-specific assembler checks.
3402 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3403 gcc_cv_ld_static_dynamic=no
3404 gcc_cv_ld_static_option='-Bstatic'
3405 gcc_cv_ld_dynamic_option='-Bdynamic'
3406 if test $in_tree_ld = yes ; then
3407 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
3408 gcc_cv_ld_static_dynamic=yes
3410 elif test x$gcc_cv_ld != x; then
3411 # Check if linker supports -Bstatic/-Bdynamic option
3412 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3413 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3414 gcc_cv_ld_static_dynamic=yes
3417 # AIX ld uses -b flags
3418 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3419 gcc_cv_ld_static_dynamic=yes
3420 gcc_cv_ld_static_option="-bstatic"
3421 gcc_cv_ld_dynamic_option="-bdynamic"
3423 # HP-UX ld uses -a flags to select between shared and archive.
3425 if test x"$gnu_ld" = xno; then
3426 gcc_cv_ld_static_dynamic=yes
3427 gcc_cv_ld_static_option="-aarchive_shared"
3428 gcc_cv_ld_dynamic_option="-adefault"
3431 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3433 gcc_cv_ld_static_dynamic=yes
3438 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3439 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3440 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3441 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3442 [Define to the linker option to disable use of shared objects.])
3443 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3444 [Define to the linker option to enable use of shared objects.])
3446 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3448 if test x"$demangler_in_ld" = xyes; then
3449 AC_MSG_CHECKING(linker --demangle support)
3450 gcc_cv_ld_demangle=no
3451 if test $in_tree_ld = yes; then
3452 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 \
3453 gcc_cv_ld_demangle=yes
3455 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3456 # Check if the GNU linker supports --demangle option
3457 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3458 gcc_cv_ld_demangle=yes
3461 if test x"$gcc_cv_ld_demangle" = xyes; then
3462 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3463 [Define if your linker supports --demangle option.])
3465 AC_MSG_RESULT($gcc_cv_ld_demangle)
3468 AC_MSG_CHECKING(linker plugin support)
3470 if test -f liblto_plugin.la; then
3471 save_ld_ver="$ld_ver"
3472 save_ld_vers_major="$ld_vers_major"
3473 save_ld_vers_minor="$ld_vers_minor"
3474 save_ld_is_gold="$ld_is_gold"
3478 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3480 # FIXME: ld_is_gold?
3481 ld_vers_major="$gcc_cv_gld_major_version"
3482 ld_vers_minor="$gcc_cv_gld_minor_version"
3484 # Determine plugin linker version.
3485 # FIXME: Partial duplicate from above, generalize.
3487 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3488 if echo "$ld_ver" | grep GNU > /dev/null; then
3489 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3491 ld_vers=`echo $ld_ver | sed -n \
3492 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3494 ld_vers=`echo $ld_ver | sed -n \
3495 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3497 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3498 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3503 # Determine plugin support.
3504 if echo "$ld_ver" | grep GNU > /dev/null; then
3505 # Require GNU ld or gold 2.21+ for plugin support by default.
3506 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3508 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3509 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3514 ld_ver="$save_ld_ver"
3515 ld_vers_major="$save_ld_vers_major"
3516 ld_vers_minor="$save_ld_vers_minor"
3517 ld_is_gold="$save_ld_is_gold"
3519 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3520 [Define to the level of your linker's plugin support.])
3521 AC_MSG_RESULT($gcc_cv_lto_plugin)
3525 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3526 [-mabi=lp64], [.text],,,)
3527 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3528 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3529 [Define if your assembler supports the -mabi option.])
3531 if test x$with_abi = xilp32; then
3532 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3533 Upgrade the Assembler.])
3535 if test x"$with_multilib_list" = xdefault; then
3536 TM_MULTILIB_CONFIG=lp64
3538 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3539 for aarch64_multilib in ${aarch64_multilibs}; do
3540 case ${aarch64_multilib} in
3542 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3543 Upgrade the Assembler.])
3553 # All TARGET_ABI_OSF targets.
3554 alpha*-*-linux* | alpha*-*-*bsd*)
3555 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3556 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3559 extbl $3, $2, $3 !lituse_bytoff!1
3560 ldq $2, a($29) !literal!1
3561 ldq $4, b($29) !literal!2
3562 ldq_u $3, 0($2) !lituse_base!1
3563 ldq $27, f($29) !literal!5
3564 jsr $26, ($27), f !lituse_jsr!5
3565 ldah $29, 0($26) !gpdisp!3
3566 lda $0, c($29) !gprel
3567 ldah $1, d($29) !gprelhigh
3568 lda $1, d($1) !gprellow
3569 lda $29, 0($29) !gpdisp!3],,
3570 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3571 [Define if your assembler supports explicit relocations.])])
3572 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3573 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3576 ldq $27, a($29) !literal!1
3577 jsr $26, ($27), a !lituse_jsrdirect!1],,
3578 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3579 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3583 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3584 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3585 [-no-mul-bug-abort], [.text],,
3586 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3587 [Define if your assembler supports the -no-mul-bug-abort option.])])
3591 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3592 [.register %g2, #scratch],,
3593 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3594 [Define if your assembler supports .register.])])
3596 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3597 [.section "nobits",#alloc,#write,#nobits
3598 .section "progbits",#alloc,#write,#progbits])
3599 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3600 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3601 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3603 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3605 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3606 [Define if your assembler supports -relax option.])])
3608 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3609 gcc_cv_as_sparc_gotdata_op,,
3616 sethi %gdop_hix22(foo), %g1
3617 xor %g1, %gdop_lox10(foo), %g1
3618 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3619 [if test x$gcc_cv_ld != x \
3620 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3621 if test x$gcc_cv_objdump != x; then
3622 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3623 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3624 gcc_cv_as_sparc_gotdata_op=no
3626 gcc_cv_as_sparc_gotdata_op=yes
3631 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3632 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3634 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3635 gcc_cv_as_sparc_ua_pcrel,,
3643 .uaword %r_disp32(foo)],
3644 [if test x$gcc_cv_ld != x \
3645 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3646 gcc_cv_as_sparc_ua_pcrel=yes
3649 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3650 [Define if your assembler and linker support unaligned PC relative relocs.])
3652 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3653 gcc_cv_as_sparc_ua_pcrel_hidden,,
3658 .uaword %r_disp32(foo)
3659 .byte 0x32, 0x33, 0x34
3664 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3665 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3666 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3667 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3668 if $gcc_cv_objdump -R conftest 2> /dev/null \
3669 | grep 'DISP32' > /dev/null 2>&1; then
3672 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3676 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3677 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3678 ]) # unaligned pcrel relocs
3680 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3681 gcc_cv_as_sparc_offsetable_lo10,,
3684 or %g1, %lo(ab) + 12, %g1
3685 or %g1, %lo(ab + 12), %g1],
3686 [if test x$gcc_cv_objdump != x \
3687 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3688 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3689 gcc_cv_as_sparc_offsetable_lo10=yes
3691 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3692 [Define if your assembler supports offsetable %lo().])])
3694 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3695 gcc_cv_as_sparc_fmaf,,
3698 .register %g2, #scratch
3699 .register %g3, #scratch
3701 fmaddd %f0, %f2, %f4, %f6
3702 addxccc %g1, %g2, %g3
3703 fsrl32 %f2, %f4, %f8
3704 fnaddd %f10, %f12, %f14],,
3705 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3706 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3708 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3709 gcc_cv_as_sparc_sparc4,,
3712 .register %g2, #scratch
3713 .register %g3, #scratch
3716 1: cwbneg %g2, %g3, 1f
3719 aes_kexpand0 %f4, %f6, %f8
3720 des_round %f38, %f40, %f42, %f44
3721 camellia_f %f54, %f56, %f58, %f60
3722 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3723 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3724 [Define if your assembler supports SPARC4 instructions.])])
3726 gcc_GAS_CHECK_FEATURE([LEON instructions],
3727 gcc_cv_as_sparc_leon,,
3730 .register %g2, #scratch
3731 .register %g3, #scratch
3735 cas [[%g2]], %g3, %g1],,
3736 [AC_DEFINE(HAVE_AS_LEON, 1,
3737 [Define if your assembler supports LEON instructions.])])
3741 i[34567]86-*-* | x86_64-*-*)
3745 # Full C++ conformance when using a shared libstdc++-v3 requires some
3746 # support from the Cygwin DLL, which in more recent versions exports
3747 # wrappers to aid in interposing and redirecting operators new, delete,
3748 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3749 # are configuring for a version of Cygwin that exports the wrappers.
3750 if test x$host = x$target && test x$host_cpu = xi686; then
3751 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3753 # Can't check presence of libc functions during cross-compile, so
3754 # we just have to assume we're building for an up-to-date target.
3755 gcc_ac_cygwin_dll_wrappers=yes
3757 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3758 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3759 [Define if you want to generate code by default that assumes that the
3760 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3763 cygwin* | pe | mingw32* | interix*)
3764 # Recent binutils allows the three-operand form of ".comm" on PE. This
3765 # definition is used unconditionally to initialise the default state of
3766 # the target option variable that governs usage of the feature.
3767 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3768 [2,19,52],,[.comm foo,1,32])
3769 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3770 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3771 [Define if your assembler supports specifying the alignment
3772 of objects allocated using the GAS .comm command.])
3773 # Used for DWARF 2 in PE
3774 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3775 gcc_cv_as_ix86_pe_secrel32,
3781 [if test x$gcc_cv_ld != x \
3782 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3783 gcc_cv_as_ix86_pe_secrel32=yes
3786 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3787 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3788 # Test if the assembler supports the extended form of the .section
3789 # directive that specifies section alignment. LTO support uses this,
3790 # but normally only after installation, so we warn but don't fail the
3791 # configure if LTO is enabled but the assembler does not support it.
3792 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3793 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3794 if test x$gcc_cv_as_section_has_align != xyes; then
3795 case ",$enable_languages," in
3797 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3801 # Test if the assembler supports the section flag 'e' for specifying
3802 # an excluded section.
3803 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3807 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3808 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3809 [Define if your assembler supports specifying the section flag e.])
3813 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3814 gcc_cv_as_ix86_filds,,,
3815 [filds mem; fists mem],,
3816 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3817 [Define if your assembler uses filds and fists mnemonics.])])
3819 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3820 gcc_cv_as_ix86_fildq,,,
3821 [fildq mem; fistpq mem],,
3822 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3823 [Define if your assembler uses fildq and fistq mnemonics.])])
3825 gcc_GAS_CHECK_FEATURE([cmov syntax],
3826 gcc_cv_as_ix86_cmov_sun_syntax,,,
3827 [cmovl.l %edx, %eax],,
3828 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3829 [Define if your assembler supports the Sun syntax for cmov.])])
3831 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3832 gcc_cv_as_ix86_ffreep,,,
3834 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3835 [Define if your assembler supports the ffreep mnemonic.])])
3837 gcc_GAS_CHECK_FEATURE([.quad directive],
3838 gcc_cv_as_ix86_quad,,,
3840 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3841 [Define if your assembler supports the .quad directive.])])
3843 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3844 gcc_cv_as_ix86_sahf,,,
3847 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3848 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3850 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3851 gcc_cv_as_ix86_interunit_movq,,,
3855 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3856 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3857 [Define if your assembler supports interunit movq mnemonic.])
3859 gcc_GAS_CHECK_FEATURE([hle prefixes],
3860 gcc_cv_as_ix86_hle,,,
3861 [lock xacquire cmpxchg %esi, (%ecx)],,
3862 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3863 [Define if your assembler supports HLE prefixes.])])
3865 gcc_GAS_CHECK_FEATURE([swap suffix],
3866 gcc_cv_as_ix86_swap,,,
3867 [movl.s %esp, %ebp],,
3868 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3869 [Define if your assembler supports the swap suffix.])])
3871 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3872 gcc_cv_as_ix86_diff_sect_delta,,,
3880 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3881 [Define if your assembler supports the subtraction of symbols in different sections.])])
3883 # These two are used unconditionally by i386.[ch]; it is to be defined
3884 # to 1 if the feature is present, 0 otherwise.
3885 as_ix86_gotoff_in_data_opt=
3886 if test x$gas = xyes; then
3887 as_ix86_gotoff_in_data_opt="--32"
3889 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3890 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3891 [$as_ix86_gotoff_in_data_opt],
3897 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3898 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3899 [Define true if the assembler supports '.long foo@GOTOFF'.])
3901 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3902 gcc_cv_as_ix86_rep_lock_prefix,,,
3908 lock addl %edi, (%eax,%esi)
3909 lock orl $0, (%esp)],,
3910 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3911 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3913 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3914 gcc_cv_as_ix86_ud2,,,
3916 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3917 [Define if your assembler supports the 'ud2' mnemonic.])])
3919 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3920 gcc_cv_as_ix86_tlsgdplt,,,
3921 [call tls_gd@tlsgdplt],
3922 [if test x$gcc_cv_ld != x \
3923 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3924 gcc_cv_as_ix86_tlsgdplt=yes
3927 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3928 [Define if your assembler and linker support @tlsgdplt.])])
3931 .section .tdata,"aw'$tls_section_flag'",@progbits
3933 .section .text,"ax",@progbits
3934 call tls_ld@tlsldmplt'
3935 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3936 gcc_cv_as_ix86_tlsldmplt,,,
3938 [if test x$gcc_cv_ld != x \
3939 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3940 gcc_cv_as_ix86_tlsldmplt=yes
3943 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3944 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3945 [Define to 1 if your assembler and linker support @tlsldmplt.])
3947 # Enforce 32-bit output with gas and gld.
3948 if test x$gas = xyes; then
3949 as_ix86_tls_ldm_opt="--32"
3951 if echo "$ld_ver" | grep GNU > /dev/null; then
3952 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3953 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3955 ld_ix86_tls_ldm_opt="-melf_i386"
3959 .section .text,"ax",@progbits
3961 .type _start, @function
3963 leal value@tlsldm(%ebx), %eax
3964 call ___tls_get_addr@plt
3966 .section .tdata,"aw'$tls_section_flag'",@progbits
3967 .type value, @object
3969 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
3970 gcc_cv_as_ix86_tlsldm,,
3971 [$as_ix86_tls_ldm_opt],
3973 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3974 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
3975 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
3976 || dis conftest 2>/dev/null | grep nop > /dev/null; then
3977 gcc_cv_as_ix86_tlsldm=yes
3981 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
3982 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
3983 [Define to 1 if your assembler and linker support @tlsldm.])
3988 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
3989 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
3991 addl r15 = @ltoffx(x#), gp
3993 ld8.mov r16 = [[r15]], x#],,
3994 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
3995 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4001 *-*-aix*) conftest_s=' .machine "pwr5"
4005 gcc_GAS_CHECK_FEATURE([.machine directive support],
4006 gcc_cv_as_machine_directive,,,
4007 [ .machine ppc7400])
4008 if test x$gcc_cv_as_machine_directive != xyes; then
4009 echo "*** This target requires an assembler supporting \".machine\"" >&2
4010 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4011 test x$build = x$target && exit 1
4015 *) conftest_s=' .machine power4
4020 gcc_GAS_CHECK_FEATURE([mfcr field support],
4021 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4023 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4024 [Define if your assembler supports mfcr field.])])
4027 *-*-aix*) conftest_s=' .machine "pwr5"
4030 *) conftest_s=' .machine power5
4035 gcc_GAS_CHECK_FEATURE([popcntb support],
4036 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4038 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4039 [Define if your assembler supports popcntb field.])])
4042 *-*-aix*) conftest_s=' .machine "pwr5x"
4045 *) conftest_s=' .machine power5
4050 gcc_GAS_CHECK_FEATURE([fp round support],
4051 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4053 [AC_DEFINE(HAVE_AS_FPRND, 1,
4054 [Define if your assembler supports fprnd.])])
4057 *-*-aix*) conftest_s=' .machine "pwr6"
4060 *) conftest_s=' .machine power6
4065 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4066 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4068 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4069 [Define if your assembler supports mffgpr and mftgpr.])])
4072 *-*-aix*) conftest_s=' .csect .text[[PR]]
4074 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4078 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4079 *) conftest_s=' .text
4081 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4084 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4085 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4087 [AC_DEFINE(HAVE_AS_REL16, 1,
4088 [Define if your assembler supports R_PPC_REL16 relocs.])])
4091 *-*-aix*) conftest_s=' .machine "pwr6"
4094 *) conftest_s=' .machine power6
4099 gcc_GAS_CHECK_FEATURE([compare bytes support],
4100 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4102 [AC_DEFINE(HAVE_AS_CMPB, 1,
4103 [Define if your assembler supports cmpb.])])
4106 *-*-aix*) conftest_s=' .machine "pwr6"
4109 *) conftest_s=' .machine power6
4114 gcc_GAS_CHECK_FEATURE([decimal float support],
4115 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4117 [AC_DEFINE(HAVE_AS_DFP, 1,
4118 [Define if your assembler supports DFP instructions.])])
4121 *-*-aix*) conftest_s=' .machine "pwr7"
4124 *) conftest_s=' .machine power7
4129 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4130 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4132 [AC_DEFINE(HAVE_AS_VSX, 1,
4133 [Define if your assembler supports VSX instructions.])])
4136 *-*-aix*) conftest_s=' .machine "pwr7"
4139 *) conftest_s=' .machine power7
4144 gcc_GAS_CHECK_FEATURE([popcntd support],
4145 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4147 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4148 [Define if your assembler supports POPCNTD instructions.])])
4151 *-*-aix*) conftest_s=' .machine "pwr8"
4152 .csect .text[[PR]]';;
4153 *) conftest_s=' .machine power8
4157 gcc_GAS_CHECK_FEATURE([power8 support],
4158 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4160 [AC_DEFINE(HAVE_AS_POWER8, 1,
4161 [Define if your assembler supports POWER8 instructions.])])
4164 *-*-aix*) conftest_s=' .csect .text[[PR]]
4166 *) conftest_s=' .text
4170 gcc_GAS_CHECK_FEATURE([lwsync support],
4171 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4173 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4174 [Define if your assembler supports LWSYNC instructions.])])
4177 *-*-aix*) conftest_s=' .machine "476"
4180 *) conftest_s=' .machine "476"
4185 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4186 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4188 [AC_DEFINE(HAVE_AS_DCI, 1,
4189 [Define if your assembler supports the DCI/ICI instructions.])])
4191 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4192 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4193 [.gnu_attribute 4,1],,
4194 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4195 [Define if your assembler supports .gnu_attribute.])])
4197 gcc_GAS_CHECK_FEATURE([tls marker support],
4198 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4199 [ bl __tls_get_addr(x@tlsgd)],,
4200 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4201 [Define if your assembler supports arg info for __tls_get_addr.])])
4205 gcc_GAS_CHECK_FEATURE([.ref support],
4206 gcc_cv_as_aix_ref, [2,21,0],,
4207 [ .csect stuff[[rw]]
4213 [AC_DEFINE(HAVE_AS_REF, 1,
4214 [Define if your assembler supports .ref])])
4220 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4221 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4222 [ lw $4,%gp_rel(foo)($4)],,
4223 [if test x$target_cpu_default = x
4224 then target_cpu_default=MASK_EXPLICIT_RELOCS
4225 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4227 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4228 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4229 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4230 [Define if the assembler understands -mno-shared.])])
4232 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4233 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4234 [.gnu_attribute 4,1],,
4235 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4236 [Define if your assembler supports .gnu_attribute.])])
4238 gcc_GAS_CHECK_FEATURE([.micromips support],
4239 gcc_cv_as_micromips_support,,[--fatal-warnings],
4241 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4242 [Define if your assembler supports the .set micromips directive])])
4244 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4245 gcc_cv_as_mips_dtprelword, [2,18,0],,
4246 [.section .tdata,"awT",@progbits
4250 .dtprelword x+0x8000],,
4251 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4252 [Define if your assembler supports .dtprelword.])])
4254 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4255 gcc_cv_as_mips_dspr1_mult,,,
4265 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4266 [Define if your assembler supports DSPR1 mult.])])
4268 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4269 gcc_cv_as_ld_jalr_reloc=no
4270 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4271 if test $in_tree_ld = yes ; then
4272 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 \
4273 && test $in_tree_ld_is_elf = yes; then
4274 gcc_cv_as_ld_jalr_reloc=yes
4276 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4277 echo ' .ent x' > conftest.s
4278 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
4279 echo ' ld $25,%call16(y)($28)' >> conftest.s
4280 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4281 echo '1: jalr $25' >> conftest.s
4282 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4283 echo '1: jalr $25' >> conftest.s
4284 echo ' .end x' >> conftest.s
4285 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4286 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4287 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4288 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4289 gcc_cv_as_ld_jalr_reloc=yes
4295 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4296 if test x$target_cpu_default = x; then
4297 target_cpu_default=MASK_RELAX_PIC_CALLS
4299 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4302 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4304 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4305 [gcc_cv_ld_mips_personality_relaxation],
4306 [gcc_cv_ld_mips_personality_relaxation=no
4307 if test $in_tree_ld = yes ; then
4308 if test "$gcc_cv_gld_major_version" -eq 2 \
4309 -a "$gcc_cv_gld_minor_version" -ge 21 \
4310 -o "$gcc_cv_gld_major_version" -gt 2; then
4311 gcc_cv_ld_mips_personality_relaxation=yes
4313 elif test x$gcc_cv_as != x \
4314 -a x$gcc_cv_ld != x \
4315 -a x$gcc_cv_readelf != x ; then
4316 cat > conftest.s <<EOF
4318 .cfi_personality 0x80,indirect_ptr
4325 .section .data,"aw",@progbits
4329 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4330 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4331 if $gcc_cv_readelf -d conftest 2>&1 \
4332 | grep TEXTREL > /dev/null 2>&1; then
4334 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4335 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4338 gcc_cv_ld_mips_personality_relaxation=yes
4342 rm -f conftest.s conftest.o conftest])
4343 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4344 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4345 [Define if your linker can relax absolute .eh_frame personality
4346 pointers into PC-relative form.])
4349 gcc_GAS_CHECK_FEATURE([-mnan= support],
4350 gcc_cv_as_mips_nan,,
4352 [AC_DEFINE(HAVE_AS_NAN, 1,
4353 [Define if the assembler understands -mnan=.])])
4354 if test x$gcc_cv_as_mips_nan = xno \
4355 && test x$with_nan != x; then
4357 [Requesting --with-nan= requires assembler support for -mnan=])
4362 # Mips and HP-UX need the GNU assembler.
4363 # Linux on IA64 might be able to use the Intel assembler.
4366 mips*-*-* | *-*-hpux* )
4367 if test x$gas_flag = xyes \
4368 || test x"$host" != x"$build" \
4369 || test ! -x "$gcc_cv_as" \
4370 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4373 echo "*** This configuration requires the GNU assembler" >&2
4379 # ??? Not all targets support dwarf2 debug_line, even within a version
4380 # of gas. Moreover, we need to emit a valid instruction to trigger any
4381 # info to the output file. So, as supported targets are added to gas 2.11,
4382 # add some instruction here to (also) show we expect this might work.
4383 # ??? Once 2.11 is released, probably need to add first known working
4384 # version to the per-target configury.
4386 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4387 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4388 | xstormy16 | xtensa)
4398 if test x"$insn" != x; then
4400 .file 1 \"conftest.s\"
4403 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4404 gcc_cv_as_dwarf2_debug_line,
4405 [elf,2,11,0],, [$conftest_s],
4406 [if test x$gcc_cv_objdump != x \
4407 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4408 | grep debug_line > /dev/null 2>&1; then
4409 gcc_cv_as_dwarf2_debug_line=yes
4412 # The .debug_line file table must be in the exact order that
4413 # we specified the files, since these indices are also used
4414 # by DW_AT_decl_file. Approximate this test by testing if
4415 # the assembler bitches if the same index is assigned twice.
4416 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4417 gcc_cv_as_dwarf2_file_buggy,,,
4421 if test $gcc_cv_as_dwarf2_debug_line = yes \
4422 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4423 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4424 [Define if your assembler supports dwarf2 .file/.loc directives,
4425 and preserves file table indices exactly as given.])
4428 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4429 gcc_cv_as_gdwarf2_flag,
4430 [elf,2,11,0], [--gdwarf2], [$insn],,
4431 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4432 [Define if your assembler supports the --gdwarf2 option.])])
4434 gcc_GAS_CHECK_FEATURE([--gstabs option],
4435 gcc_cv_as_gstabs_flag,
4436 [elf,2,11,0], [--gstabs], [$insn],
4437 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4438 # and warns about it, but still exits successfully. So check for
4440 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4442 else gcc_cv_as_gstabs_flag=yes
4444 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4445 [Define if your assembler supports the --gstabs option.])])
4447 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4448 gcc_cv_as_debug_prefix_map_flag,
4449 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4450 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4451 [Define if your assembler supports the --debug-prefix-map option.])])
4454 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4457 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4458 [Define if your assembler supports .lcomm with an alignment field.])])
4460 if test x$with_sysroot = x && test x$host = x$target \
4461 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4462 && test "$prefix" != "NONE"; then
4463 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4464 [Define to PREFIX/include if cpp should also search that directory.])
4467 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4468 if test "x$with_headers" != x; then
4469 target_header_dir=$with_headers
4470 elif test "x$with_sysroot" = x; then
4471 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4472 elif test "x$with_build_sysroot" != "x"; then
4473 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4474 elif test "x$with_sysroot" = xyes; then
4475 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4477 target_header_dir="${with_sysroot}${native_system_header_dir}"
4480 target_header_dir=${native_system_header_dir}
4483 # Determine the version of glibc, if any, used on the target.
4484 AC_MSG_CHECKING([for target glibc version])
4485 AC_ARG_WITH([glibc-version],
4486 [AS_HELP_STRING([--with-glibc-version=M.N],
4487 [assume GCC used with glibc version M.N or later])], [
4488 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4489 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4490 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4492 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4494 glibc_version_major=0
4495 glibc_version_minor=0
4496 [if test -f $target_header_dir/features.h \
4497 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4498 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4499 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4500 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4502 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4504 AC_ARG_ENABLE(gnu-unique-object,
4505 [AS_HELP_STRING([--enable-gnu-unique-object],
4506 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4507 [case $enable_gnu_unique_object in
4509 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4510 Valid choices are 'yes' and 'no'.]) ;;
4512 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4514 [.type foo, '$target_type_format_char'gnu_unique_object],,
4515 # We need to unquote above to to use the definition from config.gcc.
4516 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4517 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4519 if test x$enable_gnu_unique_object = xyes; then
4520 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4521 [Define if your assembler supports @gnu_unique_object.])
4524 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4525 [gcc_cv_as_line_zero],
4526 [gcc_cv_as_line_zero=no
4527 if test $in_tree_gas = yes; then
4528 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4529 elif test "x$gcc_cv_as" != x; then
4530 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4531 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4532 test "x`cat conftest.out`" = x
4534 gcc_cv_as_line_zero=yes
4536 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4537 cat conftest.s >&AS_MESSAGE_LOG_FD
4538 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4539 cat conftest.out >&AS_MESSAGE_LOG_FD
4541 rm -f conftest.o conftest.s conftest.out
4543 if test "x$gcc_cv_as_line_zero" = xyes; then
4544 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4545 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4548 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4549 gcc_cv_ld_eh_frame_hdr=no
4550 if test $in_tree_ld = yes ; then
4551 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 \
4552 && test $in_tree_ld_is_elf = yes; then
4553 gcc_cv_ld_eh_frame_hdr=yes
4555 elif test x$gcc_cv_ld != x; then
4556 if echo "$ld_ver" | grep GNU > /dev/null; then
4557 # Check if linker supports --eh-frame-hdr option
4558 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4559 gcc_cv_ld_eh_frame_hdr=yes
4564 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4565 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4566 gcc_cv_ld_eh_frame_hdr=yes
4572 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4573 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4574 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4575 [Define if your linker supports .eh_frame_hdr.])
4577 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4579 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4580 gcc_cv_ld_eh_frame_ciev3=no
4581 if test $in_tree_ld = yes ; then
4582 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 \
4583 && test $in_tree_ld_is_elf = yes; then
4584 gcc_cv_ld_eh_frame_ciev3=yes
4586 elif test x$gcc_cv_ld != x; then
4587 if echo "$ld_ver" | grep GNU > /dev/null; then
4588 gcc_cv_ld_eh_frame_ciev3=yes
4589 if test 0"$ld_date" -lt 20040513; then
4590 if test -n "$ld_date"; then
4591 # If there was date string, but was earlier than 2004-05-13, fail
4592 gcc_cv_ld_eh_frame_ciev3=no
4593 elif test "$ld_vers_major" -lt 2; then
4594 gcc_cv_ld_eh_frame_ciev3=no
4595 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4596 gcc_cv_ld_eh_frame_ciev3=no
4602 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4603 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4604 gcc_cv_ld_eh_frame_ciev3=yes
4610 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4611 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4612 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4613 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4615 AC_MSG_CHECKING(linker position independent executable support)
4617 if test $in_tree_ld = yes ; then
4618 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 \
4619 && test $in_tree_ld_is_elf = yes; then
4622 elif test x$gcc_cv_ld != x; then
4623 # Check if linker supports -pie option
4624 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4628 if test x"$gcc_cv_ld_pie" = xyes; then
4629 AC_DEFINE(HAVE_LD_PIE, 1,
4630 [Define if your linker supports -pie option.])
4632 AC_MSG_RESULT($gcc_cv_ld_pie)
4634 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4635 gcc_cv_ld_eh_gc_sections=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" -ge 17 -o "$gcc_cv_gld_major_version" -gt 2 \
4638 && test $in_tree_ld_is_elf = yes; then
4639 gcc_cv_ld_eh_gc_sections=yes
4641 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4642 cat > conftest.s <<EOF
4645 .type _start, @function
4648 .size _start, .-_start
4649 .section .text.foo,"ax",@progbits
4650 .type foo, @function
4654 .section .gcc_except_table.foo,"a",@progbits
4657 .section .eh_frame,"a",@progbits
4660 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4661 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4662 | grep "gc-sections option ignored" > /dev/null; then
4663 gcc_cv_ld_eh_gc_sections=no
4664 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4665 | grep gcc_except_table > /dev/null; then
4666 gcc_cv_ld_eh_gc_sections=yes
4667 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4668 if test x$gcc_cv_as_comdat_group != xyes; then
4669 gcc_cv_ld_eh_gc_sections=no
4670 cat > conftest.s <<EOF
4673 .type _start, @function
4676 .size _start, .-_start
4677 .section .gnu.linkonce.t.foo,"ax",@progbits
4678 .type foo, @function
4682 .section .gcc_except_table.foo,"a",@progbits
4685 .section .eh_frame,"a",@progbits
4688 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4689 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4690 | grep "gc-sections option ignored" > /dev/null; then
4691 gcc_cv_ld_eh_gc_sections=no
4692 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4693 | grep gcc_except_table > /dev/null; then
4694 gcc_cv_ld_eh_gc_sections=yes
4700 rm -f conftest.s conftest.o conftest
4704 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4705 gcc_cv_ld_eh_gc_sections=no
4708 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4709 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4710 [Define if your linker supports garbage collection of
4711 sections in presence of EH frames.])
4713 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4715 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4716 gcc_cv_ld_eh_gc_sections_bug=no
4717 if test $in_tree_ld = yes ; then
4718 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 \
4719 && test $in_tree_ld_is_elf = yes; then
4720 gcc_cv_ld_eh_gc_sections_bug=yes
4722 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
4723 gcc_cv_ld_eh_gc_sections_bug=yes
4724 cat > conftest.s <<EOF
4727 .type _start, @function
4730 .size _start, .-_start
4731 .section .text.startup.foo,"ax",@progbits
4732 .type foo, @function
4736 .section .gcc_except_table.foo,"a",@progbits
4739 .section .eh_frame,"a",@progbits
4742 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4743 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4744 | grep "gc-sections option ignored" > /dev/null; then
4746 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4747 | grep gcc_except_table > /dev/null; then
4748 gcc_cv_ld_eh_gc_sections_bug=no
4751 rm -f conftest.s conftest.o conftest
4753 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4754 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4755 [Define if your linker has buggy garbage collection of
4756 sections support when .text.startup.foo like sections are used.])
4758 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4764 AC_CACHE_CHECK(linker --as-needed support,
4765 gcc_cv_ld_as_needed,
4766 [gcc_cv_ld_as_needed=no
4767 gcc_cv_ld_as_needed_option='--as-needed'
4768 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4769 if test $in_tree_ld = yes ; then
4770 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 \
4771 && test $in_tree_ld_is_elf = yes; then
4772 gcc_cv_ld_as_needed=yes
4774 elif test x$gcc_cv_ld != x; then
4775 # Check if linker supports --as-needed and --no-as-needed options
4776 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4777 gcc_cv_ld_as_needed=yes
4780 # Solaris 2 ld always supports -z ignore/-z record.
4782 gcc_cv_ld_as_needed=yes
4783 gcc_cv_ld_as_needed_option="-z ignore"
4784 gcc_cv_ld_no_as_needed_option="-z record"
4789 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4790 # dl_iterate_phdr, i.e. since Solaris 11.
4792 *-*-solaris2.1[[1-9]]*)
4794 i?86-*-* | x86_64-*-*)
4795 if echo "$ld_ver" | grep GNU > /dev/null; then
4796 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4797 gcc_cv_ld_as_needed=no
4803 gcc_cv_ld_as_needed=no
4807 if test x"$gcc_cv_ld_as_needed" = xyes; then
4808 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4809 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4810 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4811 [Define to the linker option to ignore unused dependencies.])
4812 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4813 [Define to the linker option to keep unused dependencies.])
4816 case "$target:$tm_file" in
4817 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4820 emul_name="-melf64lppc"
4823 emul_name="-melf64ppc"
4826 emul_name="-melf64ppc_fbsd"
4829 AC_CACHE_CHECK(linker support for omitting dot symbols,
4830 gcc_cv_ld_no_dot_syms,
4831 [gcc_cv_ld_no_dot_syms=no
4832 if test x"$ld_is_gold" = xyes; then
4833 gcc_cv_ld_no_dot_syms=yes
4834 elif test $in_tree_ld = yes ; then
4835 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
4836 gcc_cv_ld_no_dot_syms=yes
4838 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4839 cat > conftest1.s <<EOF
4843 cat > conftest2.s <<EOF
4844 .section ".opd","aw"
4849 .quad .LEfoo,.TOC.@tocbase,0
4855 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4856 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4857 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4858 gcc_cv_ld_no_dot_syms=yes
4860 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4863 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4864 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4865 [Define if your PowerPC64 linker only needs function descriptor syms.])
4868 AC_CACHE_CHECK(linker large toc support,
4869 gcc_cv_ld_large_toc,
4870 [gcc_cv_ld_large_toc=no
4871 if test x"$ld_is_gold" = xyes; then
4872 gcc_cv_ld_large_toc=yes
4873 elif test $in_tree_ld = yes ; then
4874 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
4875 gcc_cv_ld_large_toc=yes
4877 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4878 cat > conftest.s <<EOF
4879 .section ".tbss","awT",@nobits
4885 addis 9,13,ie0@got@tprel@ha
4886 ld 9,ie0@got@tprel@l(9)
4888 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
4889 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
4890 gcc_cv_ld_large_toc=yes
4892 rm -f conftest conftest.o conftest.s
4895 if test x"$gcc_cv_ld_large_toc" = xyes; then
4896 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4897 [Define if your PowerPC64 linker supports a large TOC.])
4904 AC_CACHE_CHECK(linker large toc support,
4905 gcc_cv_ld_large_toc,
4906 [gcc_cv_ld_large_toc=no
4907 if test x$gcc_cv_as != x ; then
4908 cat > conftest.s <<EOF
4918 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
4919 gcc_cv_ld_large_toc=yes
4921 rm -f conftest conftest.o conftest.s
4924 if test x"$gcc_cv_ld_large_toc" = xyes; then
4925 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
4926 [Define if your PowerPC64 linker supports a large TOC.])
4931 AC_CACHE_CHECK(linker --build-id support,
4933 [gcc_cv_ld_buildid=no
4934 if test $in_tree_ld = yes ; then
4935 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4936 "$gcc_cv_gld_minor_version" -ge 18 -o \
4937 "$gcc_cv_gld_major_version" -gt 2 \
4938 && test $in_tree_ld_is_elf = yes; then
4939 gcc_cv_ld_buildid=yes
4941 elif test x$gcc_cv_ld != x; then
4942 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
4943 gcc_cv_ld_buildid=yes
4946 if test x"$gcc_cv_ld_buildid" = xyes; then
4947 AC_DEFINE(HAVE_LD_BUILDID, 1,
4948 [Define if your linker supports --build-id.])
4951 AC_ARG_ENABLE(linker-build-id,
4952 [AS_HELP_STRING([--enable-linker-build-id],
4953 [compiler will always pass --build-id to linker])],
4955 enable_linker_build_id=no)
4957 if test x"$enable_linker_build_id" = xyes; then
4958 if test x"$gcc_cv_ld_buildid" = xyes; then
4959 AC_DEFINE(ENABLE_LD_BUILDID, 1,
4960 [Define if gcc should always pass --build-id to linker.])
4962 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
4966 # In binutils 2.21, GNU ld gained support for new emulations fully
4967 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
4968 AC_CACHE_CHECK(linker *_sol2 emulation support,
4969 gcc_cv_ld_sol2_emulation,
4970 [gcc_cv_ld_sol2_emulation=no
4971 if test $in_tree_ld = yes ; then
4972 if test "$gcc_cv_gld_major_version" -eq 2 -a \
4973 "$gcc_cv_gld_minor_version" -ge 21 -o \
4974 "$gcc_cv_gld_major_version" -gt 2 \
4975 && test $in_tree_ld_is_elf = yes; then
4976 gcc_cv_ld_sol2_emulation=yes
4978 elif test x$gcc_cv_ld != x; then
4979 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
4980 grep _sol2 > /dev/null; then
4981 gcc_cv_ld_sol2_emulation=yes
4984 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
4985 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
4986 [Define if your linker supports the *_sol2 emulations.])
4989 AC_CACHE_CHECK(linker --sysroot support,
4991 [gcc_cv_ld_sysroot=no
4992 if test $in_tree_ld = yes ; then
4993 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
4994 gcc_cv_ld_sysroot=yes
4996 elif test x$gcc_cv_ld != x; then
4997 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
4998 gcc_cv_ld_sysroot=yes
5001 if test x"$gcc_cv_ld_sysroot" = xyes; then
5002 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5003 [Define if your linker supports --sysroot.])
5006 # Test for stack protector support in target C library.
5007 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5008 gcc_cv_libc_provides_ssp,
5009 [gcc_cv_libc_provides_ssp=no
5011 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5012 # glibc 2.4 and later provides __stack_chk_fail and
5013 # either __stack_chk_guard, or TLS access to stack guard canary.
5014 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5015 [if test -f $target_header_dir/features.h \
5016 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5017 $target_header_dir/features.h > /dev/null; then
5018 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5019 $target_header_dir/features.h > /dev/null && \
5020 test -f $target_header_dir/bits/uClibc_config.h && \
5021 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5022 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5023 gcc_cv_libc_provides_ssp=yes
5025 # all versions of Bionic support stack protector
5026 elif test -f $target_header_dir/sys/cdefs.h \
5027 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5028 $target_header_dir/sys/cdefs.h > /dev/null; then
5029 gcc_cv_libc_provides_ssp=yes
5033 # Avoid complicated tests (see
5034 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5035 # simply assert that glibc does provide this, which is true for all
5036 # realistically usable GNU/Hurd configurations.
5037 gcc_cv_libc_provides_ssp=yes;;
5038 *-*-darwin* | *-*-freebsd*)
5039 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5040 [echo "no __stack_chk_fail on this target"])
5042 *) gcc_cv_libc_provides_ssp=no ;;
5045 if test x$gcc_cv_libc_provides_ssp = xyes; then
5046 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5047 [Define if your target C library provides stack protector support])
5050 # Test for <sys/sdt.h> on the target.
5051 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5052 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5054 if test -f $target_header_dir/sys/sdt.h; then
5056 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5057 [Define if your target C library provides sys/sdt.h])
5059 AC_MSG_RESULT($have_sys_sdt_h)
5061 # Check if TFmode long double should be used by default or not.
5062 # Some glibc targets used DFmode long double, but with glibc 2.4
5063 # and later they can use TFmode.
5065 powerpc*-*-linux* | \
5069 AC_ARG_WITH(long-double-128,
5070 [AS_HELP_STRING([--with-long-double-128],
5071 [use 128-bit long double by default])],
5072 gcc_cv_target_ldbl128="$with_long_double_128",
5073 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5074 [gcc_cv_target_ldbl128=no
5075 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5076 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5077 && gcc_cv_target_ldbl128=yes
5081 if test x$gcc_cv_target_ldbl128 = xyes; then
5082 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5083 [Define if TFmode long double should be the default])
5086 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5087 gcc_cv_target_dl_iterate_phdr=unknown
5089 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5090 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5091 # libdl there, both complicating its use and breaking compatibility
5092 # between Solaris 10 updates.
5093 *-*-solaris2.1[[1-9]]*)
5094 # <link.h> needs both a dl_iterate_phdr declaration and support for
5095 # compilation with largefile support.
5096 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5097 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5098 gcc_cv_target_dl_iterate_phdr=yes
5100 gcc_cv_target_dl_iterate_phdr=no
5104 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5105 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5106 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5107 [Define if your target C library provides the `dl_iterate_phdr' function.])
5109 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5111 # We no longer support different GC mechanisms. Emit an error if
5112 # the user configures with --with-gc.
5114 [AS_HELP_STRING([--with-gc={page,zone}],
5115 [this option is not supported anymore. It used to choose
5116 the garbage collection mechanism to use with the compiler])],
5117 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5120 # Libraries to use on the host. This will normally be set by the top
5121 # level Makefile. Here we simply capture the value for our Makefile.
5122 if test -z "${HOST_LIBS+set}"; then
5127 # Use the system's zlib library.
5129 zlibinc="-I\$(srcdir)/../zlib"
5130 AC_ARG_WITH(system-zlib,
5131 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5138 dnl Very limited version of automake's enable-maintainer-mode
5140 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5141 dnl maintainer-mode is disabled by default
5142 AC_ARG_ENABLE(maintainer-mode,
5143 [AS_HELP_STRING([--enable-maintainer-mode],
5144 [enable make rules and dependencies not useful
5145 (and sometimes confusing) to the casual installer])],
5146 maintainer_mode=$enableval,
5149 AC_MSG_RESULT($maintainer_mode)
5151 if test "$maintainer_mode" = "yes"; then
5158 dnl Whether to prevent multiple front-ends from linking at the same time
5160 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5161 AC_ARG_ENABLE(link-mutex,
5162 [AS_HELP_STRING([--enable-link-mutex],
5163 [avoid linking multiple front-ends at once to avoid thrashing
5164 on the build machine])],
5165 do_link_mutex=$enableval,
5167 AC_MSG_RESULT($do_link_mutex)
5169 if test "$do_link_mutex" = "yes"; then
5174 AC_SUBST(DO_LINK_MUTEX)
5180 # Make empty files to contain the specs and options for each language.
5181 # Then add #include lines to for a compiler that has specs and/or options.
5187 # These (without "all_") are set in each config-lang.in.
5188 # `language' must be a single word so is spelled singularly.
5191 all_outputs='Makefile'
5192 # List of language makefile fragments.
5194 # Additional files for gengtype
5195 all_gtfiles="$target_gtfiles"
5197 # These are the languages that are set in --enable-languages,
5198 # and are available in the GCC tree.
5199 all_selected_languages=
5201 # Add the language fragments.
5202 # Languages are added via two mechanisms. Some information must be
5203 # recorded in makefile variables, these are defined in config-lang.in.
5204 # We accumulate them and plug them into the main Makefile.
5205 # The other mechanism is a set of hooks for each of the main targets
5206 # like `clean', `install', etc.
5208 language_hooks="Make-hooks"
5210 for lang in ${srcdir}/*/config-lang.in
5213 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5215 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5216 if test "x$lang_alias" = x
5218 echo "$lang doesn't set \$language." 1>&2
5221 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5222 subdirs="$subdirs $subdir"
5224 # $gcc_subdir is where the gcc integration files are to be found
5225 # for a language, both for internal compiler purposes (compiler
5226 # sources implementing front-end to GCC tree converters), and for
5227 # build infrastructure purposes (Make-lang.in, etc.)
5229 # This will be <subdir> (relative to $srcdir) if a line like
5230 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5231 # is found in <langdir>/config-lang.in, and will remain <langdir>
5234 # Except for the language alias (fetched above), the regular
5235 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5236 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5237 # only this and the language alias.
5239 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5240 if [ "$gcc_subdir" = "" ]; then
5241 gcc_subdir="$subdir"
5244 case ",$enable_languages," in
5246 all_selected_languages="$all_selected_languages $lang_alias"
5247 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5248 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5260 . ${srcdir}/$gcc_subdir/config-lang.in
5261 if test "x$language" = x
5263 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5268 case ",$enable_languages," in
5271 for i in $subdir_requires; do
5272 test -f "${srcdir}/$i/config-lang.in" && continue
5280 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5281 if test -f $srcdir/$gcc_subdir/lang.opt; then
5282 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5283 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5285 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5286 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5288 all_languages="$all_languages $language"
5289 all_compilers="$all_compilers $compilers"
5290 all_outputs="$all_outputs $outputs"
5291 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5292 case ",$enable_languages," in
5294 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5296 AC_SUBST(enable_lto)
5303 for language in $all_selected_languages
5305 check_languages="$check_languages check-$language"
5308 # We link each language in with a set of hooks, reached indirectly via
5309 # lang.${target}. Only do so for selected languages.
5313 target_list="all.cross start.encap rest.encap tags \
5314 install-common install-man install-info install-pdf install-html dvi \
5315 pdf html uninstall info man srcextra srcman srcinfo \
5316 mostlyclean clean distclean maintainer-clean install-plugin"
5318 for t in $target_list
5321 for lang in $all_selected_languages
5325 echo "lang.$t: $x" >> Make-hooks
5329 # Option include files
5332 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5333 option_includes="option-includes.mk"
5334 AC_SUBST_FILE(option_includes)
5342 echo "dir ." > .gdbinit
5343 echo "dir ${srcdir}" >> .gdbinit
5344 if test x$gdb_needs_out_file_path = xyes
5346 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5348 if test "x$subdirs" != x; then
5351 echo "dir ${srcdir}/$s" >> .gdbinit
5354 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5355 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5357 # Put a breakpoint on __asan_report_error to help with debugging buffer
5360 *-fsanitize=address*)
5361 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5365 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5366 AC_SUBST(gcc_tooldir)
5369 # Find a directory in which to install a shared libgcc.
5371 AC_ARG_ENABLE(version-specific-runtime-libs,
5372 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5373 [specify that runtime libraries should be
5374 installed in a compiler-specific directory])])
5376 # Substitute configuration variables
5379 AC_SUBST(all_compilers)
5380 AC_SUBST(all_gtfiles)
5381 AC_SUBST(all_lang_makefrags)
5382 AC_SUBST(all_languages)
5383 AC_SUBST(all_selected_languages)
5384 AC_SUBST(build_exeext)
5385 AC_SUBST(build_install_headers_dir)
5386 AC_SUBST(build_xm_file_list)
5387 AC_SUBST(build_xm_include_list)
5388 AC_SUBST(build_xm_defines)
5389 AC_SUBST(build_file_translate)
5390 AC_SUBST(check_languages)
5391 AC_SUBST(cpp_install_dir)
5392 AC_SUBST(xmake_file)
5393 AC_SUBST(tmake_file)
5394 AC_SUBST(TM_ENDIAN_CONFIG)
5395 AC_SUBST(TM_MULTILIB_CONFIG)
5396 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5397 AC_SUBST(extra_gcc_objs)
5398 AC_SUBST(user_headers_inc_next_pre)
5399 AC_SUBST(user_headers_inc_next_post)
5400 AC_SUBST(extra_headers_list)
5401 AC_SUBST(extra_objs)
5402 AC_SUBST(extra_programs)
5403 AC_SUBST(float_h_file)
5404 AC_SUBST(gcc_config_arguments)
5405 AC_SUBST(gcc_gxx_include_dir)
5406 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5407 AC_SUBST(host_exeext)
5408 AC_SUBST(host_xm_file_list)
5409 AC_SUBST(host_xm_include_list)
5410 AC_SUBST(host_xm_defines)
5411 AC_SUBST(out_host_hook_obj)
5413 AC_SUBST(lang_opt_files)
5414 AC_SUBST(lang_specs_files)
5415 AC_SUBST(lang_tree_files)
5416 AC_SUBST(local_prefix)
5418 AC_SUBST(objc_boehm_gc)
5420 AC_SUBST(out_object_file)
5421 AC_SUBST(common_out_file)
5422 AC_SUBST(common_out_object_file)
5423 AC_SUBST(tm_file_list)
5424 AC_SUBST(tm_include_list)
5425 AC_SUBST(tm_defines)
5426 AC_SUBST(tm_p_file_list)
5427 AC_SUBST(tm_p_include_list)
5428 AC_SUBST(xm_file_list)
5429 AC_SUBST(xm_include_list)
5430 AC_SUBST(xm_defines)
5431 AC_SUBST(use_gcc_stdint)
5432 AC_SUBST(c_target_objs)
5433 AC_SUBST(cxx_target_objs)
5434 AC_SUBST(fortran_target_objs)
5435 AC_SUBST(target_cpu_default)
5437 AC_SUBST_FILE(language_hooks)
5440 if test x${build} = x${host} ; then
5441 if test x${host} = x${target} ; then
5442 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5444 echo "Links are now set up to build a cross-compiler" 1>&2
5445 echo " from ${host} to ${target}." 1>&2
5448 if test x${host} = x${target} ; then
5449 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5450 echo " for ${target}." 1>&2
5452 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5453 echo " from ${host} to ${target}." 1>&2
5457 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5458 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5460 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5461 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5463 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5464 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5465 if test "x${CLOOGLIBS}" != "x" ; then
5466 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5469 # Check for plugin support
5470 AC_ARG_ENABLE(plugin,
5471 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5472 enable_plugin=$enableval,
5473 enable_plugin=yes; default_plugin=yes)
5479 if test x$build = x$host; then
5480 export_sym_check="nm${exeext} -g"
5481 elif test x$host = x$target; then
5482 export_sym_check="$gcc_cv_nm -g"
5488 if test x$build = x$host; then
5489 export_sym_check="objdump${exeext} -T"
5490 elif test x$host = x$target; then
5491 export_sym_check="$gcc_cv_objdump -T"
5498 if test x"$enable_plugin" = x"yes"; then
5500 AC_MSG_CHECKING([for exported symbols])
5501 if test "x$export_sym_check" != x; then
5502 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5503 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5504 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5505 : # No need to use a flag
5506 AC_MSG_RESULT([yes])
5508 AC_MSG_RESULT([yes])
5509 AC_MSG_CHECKING([for -rdynamic])
5510 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5511 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5513 pluginlibs="-rdynamic"
5518 AC_MSG_RESULT([$plugin_rdynamic])
5521 AC_MSG_RESULT([unable to check])
5526 AC_SEARCH_LIBS([dlopen], [dl])
5527 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5528 pluginlibs="$pluginlibs -ldl"
5532 # Check that we can build shared objects with -fPIC -shared
5533 saved_LDFLAGS="$LDFLAGS"
5534 saved_CFLAGS="$CFLAGS"
5537 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5538 CFLAGS="$CFLAGS -fPIC"
5539 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5542 CFLAGS="$CFLAGS -fPIC"
5543 LDFLAGS="$LDFLAGS -fPIC -shared"
5546 AC_MSG_CHECKING([for -fPIC -shared])
5548 [extern int X;],[return X == 0;],
5549 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5550 [AC_MSG_RESULT([no]); have_pic_shared=no])
5551 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5555 LDFLAGS="$saved_LDFLAGS"
5556 CFLAGS="$saved_CFLAGS"
5558 # If plugin support had been requested but not available, fail.
5559 if test x"$enable_plugin" = x"no" ; then
5560 if test x"$default_plugin" != x"yes"; then
5562 Building GCC with plugin support requires a host that supports
5563 -fPIC, -shared, -ldl and -rdynamic.])
5568 AC_SUBST(pluginlibs)
5569 AC_SUBST(enable_plugin)
5570 if test x"$enable_plugin" = x"yes"; then
5571 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5575 # Enable --enable-host-shared
5576 AC_ARG_ENABLE(host-shared,
5577 [AS_HELP_STRING([--enable-host-shared],
5578 [build host code as shared libraries])],
5579 [PICFLAG=-fPIC], [PICFLAG=])
5580 AC_SUBST(enable_host_shared)
5584 AC_ARG_ENABLE(libquadmath-support,
5585 [AS_HELP_STRING([--disable-libquadmath-support],
5586 [disable libquadmath support for Fortran])],
5587 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5588 ENABLE_LIBQUADMATH_SUPPORT=yes)
5589 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5590 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5591 [Define to 1 to enable libquadmath support])
5595 # Specify what hash style to use by default.
5596 AC_ARG_WITH([linker-hash-style],
5597 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5598 [specify the linker hash style])],
5599 [case x"$withval" in
5601 LINKER_HASH_STYLE=sysv
5604 LINKER_HASH_STYLE=gnu
5607 LINKER_HASH_STYLE=both
5610 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5613 [LINKER_HASH_STYLE=''])
5614 if test x"${LINKER_HASH_STYLE}" != x; then
5615 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5616 [The linker hash style])
5619 # Configure the subdirectories
5620 # AC_CONFIG_SUBDIRS($subdirs)
5622 # Create the Makefile
5623 # and configure language subdirectories
5624 AC_CONFIG_FILES($all_outputs)
5626 AC_CONFIG_COMMANDS([default],
5628 case ${CONFIG_HEADERS} in
5629 *auto-host.h:config.in*)
5632 # Make sure all the subdirs exist.
5633 for d in $subdirs doc build common c-family
5635 test -d $d || mkdir $d
5638 [subdirs='$subdirs'])