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([-Wold-style-definition -Wc++-compat])), [c_strict_warn])
344 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
345 m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ],
346 [-Wno-overlength-strings])), [strict_warn])
347 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
349 # The above macros do nothing if the compiler is not GCC. However, the
350 # Makefile has more goo to add other flags, so these variables are used
351 # to enable warnings only for GCC.
354 if test "x$GCC" = "xyes"; then
355 warn_cflags='$(GCC_WARN_CFLAGS)'
356 warn_cxxflags='$(GCC_WARN_CXXFLAGS)'
358 AC_SUBST(warn_cflags)
359 AC_SUBST(warn_cxxflags)
361 # Disable exceptions and RTTI if building with g++
362 ACX_PROG_CC_WARNING_OPTS(
363 m4_quote(m4_do([-fno-exceptions -fno-rtti -fasynchronous-unwind-tables])),
366 # Enable expensive internal checks
368 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
372 AC_ARG_ENABLE(checking,
373 [AS_HELP_STRING([[--enable-checking[=LIST]]],
374 [enable expensive run-time checks. With LIST,
375 enable only specific categories of checks.
376 Categories are: yes,no,all,none,release.
377 Flags are: assert,df,fold,gc,gcac,gimple,misc,
378 rtlflag,rtl,runtime,tree,valgrind,types])],
379 [ac_checking_flags="${enableval}"],[
380 # Determine the default checks.
381 if test x$is_release = x ; then
382 ac_checking_flags=yes
384 ac_checking_flags=release
386 IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
387 for check in release $ac_checking_flags
390 # these set all the flags to specific states
391 yes) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
392 ac_fold_checking= ; ac_gc_checking=1 ;
393 ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
394 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
395 ac_tree_checking=1 ; ac_valgrind_checking= ;
396 ac_types_checking=1 ;;
397 no|none) ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
398 ac_fold_checking= ; ac_gc_checking= ;
399 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
400 ac_rtlflag_checking= ; ac_runtime_checking= ;
401 ac_tree_checking= ; ac_valgrind_checking= ;
402 ac_types_checking= ;;
403 all) ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
404 ac_fold_checking=1 ; ac_gc_checking=1 ;
405 ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
406 ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
407 ac_tree_checking=1 ; ac_valgrind_checking= ;
408 ac_types_checking=1 ;;
409 release) ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
410 ac_fold_checking= ; ac_gc_checking= ;
411 ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
412 ac_rtlflag_checking= ; ac_runtime_checking=1 ;
413 ac_tree_checking= ; ac_valgrind_checking= ;
414 ac_types_checking= ;;
415 # these enable particular checks
416 assert) ac_assert_checking=1 ;;
417 df) ac_df_checking=1 ;;
418 fold) ac_fold_checking=1 ;;
419 gc) ac_gc_checking=1 ;;
420 gcac) ac_gc_always_collect=1 ;;
421 gimple) ac_gimple_checking=1 ;;
422 misc) ac_checking=1 ;;
423 rtl) ac_rtl_checking=1 ;;
424 rtlflag) ac_rtlflag_checking=1 ;;
425 runtime) ac_runtime_checking=1 ;;
426 tree) ac_tree_checking=1 ;;
427 types) ac_types_checking=1 ;;
428 valgrind) ac_valgrind_checking=1 ;;
429 *) AC_MSG_ERROR(unknown check category $check) ;;
435 if test x$ac_checking != x ; then
436 AC_DEFINE(ENABLE_CHECKING, 1,
437 [Define if you want more run-time sanity checks. This one gets a grab
438 bag of miscellaneous but relatively cheap checks.])
439 nocommon_flag=-fno-common
441 AC_SUBST(nocommon_flag)
442 if test x$ac_df_checking != x ; then
443 AC_DEFINE(ENABLE_DF_CHECKING, 1,
444 [Define if you want more run-time sanity checks for dataflow.])
446 if test x$ac_assert_checking != x ; then
447 AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
448 [Define if you want assertions enabled. This is a cheap check.])
450 if test x$ac_gimple_checking != x ; then
451 AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
452 [Define if you want operations on GIMPLE (the basic data structure of
453 the high-level optimizers) to be checked for dynamic type safety at
454 runtime. This is moderately expensive.])
456 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
457 if test x$ac_runtime_checking != x ; then
458 AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
459 [Define if you want runtime assertions enabled. This is a cheap check.])
461 if test x$ac_tree_checking != x ; then
462 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
463 [Define if you want all operations on trees (the basic data
464 structure of the front ends) to be checked for dynamic type safety
465 at runtime. This is moderately expensive. The tree browser debugging
466 routines will also be enabled by this option.
468 TREEBROWSER=tree-browser.o
471 if test x$ac_types_checking != x ; then
472 AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
473 [Define if you want all gimple types to be verified after gimplifiation.
477 AC_SUBST(TREEBROWSER)
478 AC_SUBST(TREECHECKING)
479 if test x$ac_rtl_checking != x ; then
480 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
481 [Define if you want all operations on RTL (the basic data structure
482 of the optimizer and back end) to be checked for dynamic type safety
483 at runtime. This is quite expensive.])
485 if test x$ac_rtlflag_checking != x ; then
486 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
487 [Define if you want RTL flag accesses to be checked against the RTL
488 codes that are supported for each access macro. This is relatively
491 if test x$ac_gc_checking != x ; then
492 AC_DEFINE(ENABLE_GC_CHECKING, 1,
493 [Define if you want the garbage collector to do object poisoning and
494 other memory allocation checks. This is quite expensive.])
496 if test x$ac_gc_always_collect != x ; then
497 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
498 [Define if you want the garbage collector to operate in maximally
499 paranoid mode, validating the entire heap and collecting garbage at
500 every opportunity. This is extremely expensive.])
502 if test x$ac_fold_checking != x ; then
503 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
504 [Define if you want fold checked that it never destructs its argument.
505 This is quite expensive.])
507 valgrind_path_defines=
510 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
511 dnl # an if statement. This was the source of very frustrating bugs
512 dnl # in converting to autoconf 2.5x!
513 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
515 if test x$ac_valgrind_checking != x ; then
516 # It is certainly possible that there's valgrind but no valgrind.h.
517 # GCC relies on making annotations so we must have both.
518 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
519 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
520 [[#include <valgrind/memcheck.h>
521 #ifndef VALGRIND_DISCARD
522 #error VALGRIND_DISCARD not defined
524 [gcc_cv_header_valgrind_memcheck_h=yes],
525 [gcc_cv_header_valgrind_memcheck_h=no])
526 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
527 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
528 AC_PREPROC_IFELSE([AC_LANG_SOURCE(
529 [[#include <memcheck.h>
530 #ifndef VALGRIND_DISCARD
531 #error VALGRIND_DISCARD not defined
533 [gcc_cv_header_memcheck_h=yes],
534 [gcc_cv_header_memcheck_h=no])
535 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
536 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
537 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
538 if test "x$valgrind_path" = "x" \
539 || (test $have_valgrind_h = no \
540 && test $gcc_cv_header_memcheck_h = no \
541 && test $gcc_cv_header_valgrind_memcheck_h = no); then
542 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
544 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
545 valgrind_command="$valgrind_path -q"
546 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
547 [Define if you want to run subprograms and generated programs
548 through valgrind (a memory checker). This is extremely expensive.])
549 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
550 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
551 [Define if valgrind's valgrind/memcheck.h header is installed.])
553 if test $gcc_cv_header_memcheck_h = yes; then
554 AC_DEFINE(HAVE_MEMCHECK_H, 1,
555 [Define if valgrind's memcheck.h header is installed.])
558 AC_SUBST(valgrind_path_defines)
559 AC_SUBST(valgrind_command)
561 # Enable code coverage collection
562 AC_ARG_ENABLE(coverage,
563 [AS_HELP_STRING([[--enable-coverage[=LEVEL]]],
564 [enable compiler's code coverage collection.
565 Use to measure compiler performance and locate
566 unused parts of the compiler. With LEVEL, specify
567 optimization. Values are opt, noopt,
569 [case "${enableval}" in
571 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
574 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
577 # a.k.a. --disable-coverage
581 AC_MSG_ERROR(unknown coverage setting $enableval)
585 AC_SUBST(coverage_flags)
587 AC_ARG_ENABLE(gather-detailed-mem-stats,
588 [AS_HELP_STRING([--enable-gather-detailed-mem-stats],
589 [enable detailed memory allocation stats gathering])], [],
590 [enable_gather_detailed_mem_stats=no])
591 gather_stats=`if test $enable_gather_detailed_mem_stats != no; then echo 1; else echo 0; fi`
592 AC_DEFINE_UNQUOTED(GATHER_STATISTICS, $gather_stats,
593 [Define to enable detailed memory allocation stats gathering.])
595 # -------------------------------
596 # Miscenalleous configure options
597 # -------------------------------
601 [AS_HELP_STRING([--with-stabs],
602 [arrange to use stabs instead of host debug format])],
606 # Determine whether or not multilibs are enabled.
607 AC_ARG_ENABLE(multilib,
608 [AS_HELP_STRING([--enable-multilib],
609 [enable library support for multiple ABIs])],
610 [], [enable_multilib=yes])
611 AC_SUBST(enable_multilib)
613 # Determine whether or not multiarch is enabled.
614 AC_ARG_ENABLE(multiarch,
615 [AS_HELP_STRING([--enable-multiarch],
616 [enable support for multiarch paths])],
617 [case "${enableval}" in
618 yes|no|auto) enable_multiarch=$enableval;;
619 *) AC_MSG_ERROR(bad value ${enableval} given for --enable-multiarch option) ;;
620 esac], [enable_multiarch=auto])
621 if test x${enable_multiarch} = xauto; then
622 if test x${with_native_system_header_dir} != x; then
623 ma_msg_suffix=", disabled auto check (configured with --native-system-header-dir)"
626 if test x$host != x$target && test "x$with_sysroot" = x; then
627 ma_msg_suffix=", disabled auto check (cross build configured without --with-sysroot)"
631 AC_MSG_CHECKING(for multiarch configuration)
632 AC_SUBST(enable_multiarch)
633 AC_MSG_RESULT($enable_multiarch$ma_msg_suffix)
635 # needed for setting the multiarch name for soft-float/hard-float ABIs
639 # Enable __cxa_atexit for C++.
640 AC_ARG_ENABLE(__cxa_atexit,
641 [AS_HELP_STRING([--enable-__cxa_atexit], [enable __cxa_atexit for C++])],
644 # Enable C extension for decimal float if target supports it.
645 GCC_AC_ENABLE_DECIMAL_FLOAT([$target])
647 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
648 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
649 [Define to 1 to enable decimal float extension to C.])
651 # Use default_decimal_float for dependency.
652 enable_decimal_float=$default_decimal_float
654 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
655 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
656 [Define to 1 to specify that we are using the BID decimal floating
657 point format instead of DPD])
659 # Enable C extension for fixed-point arithmetic.
660 AC_ARG_ENABLE(fixed-point,
661 [AS_HELP_STRING([--enable-fixed-point],
662 [enable fixed-point arithmetic extension to C])],
667 enable_fixed_point=yes
671 enable_fixed_point=yes
674 AC_MSG_WARN([fixed-point is not supported for this target, ignored])
675 enable_fixed_point=no
679 AC_SUBST(enable_fixed_point)
681 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
682 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
683 [Define to 1 to enable fixed-point arithmetic extension to C.])
686 # Pass with no value to take the default
687 # Pass with a value to specify a thread package
688 AC_ARG_ENABLE(threads,
689 [AS_HELP_STRING([[--enable-threads[=LIB]]],
690 [enable thread usage for target GCC,
691 using LIB thread package])],,
695 [AS_HELP_STRING([--enable-tls],
696 [enable or disable generation of tls code
697 overriding the assembler check for tls support])],
701 *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
702 Valid choices are 'yes' and 'no'.]) ;;
706 AC_ARG_ENABLE(objc-gc,
707 [AS_HELP_STRING([--enable-objc-gc],
708 [enable the use of Boehm's garbage collector with
709 the GNU Objective-C runtime])],
710 if test x$enable_objc_gc = xno; then
718 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
719 dwarf2="$with_dwarf2",
722 AC_ARG_ENABLE(shared,
723 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
725 case $enable_shared in
729 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
730 for pkg in $enableval; do
731 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
738 ], [enable_shared=yes])
739 AC_SUBST(enable_shared)
741 AC_ARG_WITH([native-system-header-dir],
742 [ --with-native-system-header-dir=dir
743 use dir as the directory to look for standard
744 system header files in. Defaults to /usr/include.],
746 case ${with_native_system_header_dir} in
747 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
748 /* | [[A-Za-z]]:[[\\/]]*) ;;
749 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
751 configured_native_system_header_dir="${withval}"
752 ], [configured_native_system_header_dir=])
754 AC_ARG_WITH(build-sysroot,
755 [AS_HELP_STRING([--with-build-sysroot=sysroot],
756 [use sysroot as the system root during the build])],
757 [if test x"$withval" != x ; then
758 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
760 [SYSROOT_CFLAGS_FOR_TARGET=])
761 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
763 AC_ARG_WITH([runtime-root-prefix],
764 [ --with-runtime-root-prefix=prefix
765 prepend prefix to paths used by the compiler to
766 name the dynamic linker and other files used at
767 runtime. Defaults to empty (no prefix).],
769 case ${with_runtime_root_prefix} in
770 yes|no) AC_MSG_ERROR([bad value ${withval} given for runtime root prefix]) ;;
772 *) AC_MSG_ERROR([${withval} should be an absolute directory]) ;;
774 RUNTIME_ROOT_PREFIX_DEFINE="-DRUNTIME_ROOT_PREFIX=\\\"${withval}\\\""
775 ], [RUNTIME_ROOT_PREFIX_DEFINE=""])
776 AC_SUBST(RUNTIME_ROOT_PREFIX_DEFINE)
778 if test "x$prefix" = xNONE; then
779 test_prefix=/usr/local
783 if test "x$exec_prefix" = xNONE; then
784 test_exec_prefix=$test_prefix
786 test_exec_prefix=$exec_prefix
790 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
791 [search for usr/lib, usr/include, et al, within DIR])],
793 case ${with_sysroot} in
794 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
795 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
798 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
799 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
801 case ${TARGET_SYSTEM_ROOT} in
802 "${test_prefix}"|"${test_prefix}/"*|\
803 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
804 '${prefix}'|'${prefix}/'*|\
805 '${exec_prefix}'|'${exec_prefix}/'*)
806 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
807 TARGET_SYSTEM_ROOT_DEFINE="$t"
812 TARGET_SYSTEM_ROOT_DEFINE=
813 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
815 AC_SUBST(TARGET_SYSTEM_ROOT)
816 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
817 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
820 [AS_HELP_STRING([--with-specs=SPECS],
821 [add SPECS to driver command-line processing])],
822 [CONFIGURE_SPECS=$withval],
825 AC_SUBST(CONFIGURE_SPECS)
827 ACX_PKGVERSION([GCC])
828 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
830 # Sanity check enable_languages in case someone does not run the toplevel
831 # configure # script.
832 AC_ARG_ENABLE(languages,
833 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
834 [case ,${enable_languages}, in
836 # go safe -- we cannot be much sure without the toplevel
838 # analysis of which target libs are present and usable
842 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
847 enable_languages=c,${enable_languages}
850 [enable_languages=c])
852 AC_ARG_WITH(multilib-list,
853 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
855 with_multilib_list=default)
857 # -------------------------
858 # Checks for other programs
859 # -------------------------
863 # Find some useful tools
865 # We need awk to create options.c and options.h.
866 # Bail out if it's missing.
868 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
875 AC_SUBST(ranlib_flags)
879 # See if cmp has --ignore-initial.
880 gcc_AC_PROG_CMP_IGNORE_INITIAL
882 # See if we have the mktemp command.
883 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
885 # See if makeinfo has been installed and is modern enough
886 # that we can use it.
887 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
888 [GNU texinfo.* \([0-9][0-9.]*\)],
889 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
890 if test $gcc_cv_prog_makeinfo_modern = no; then
892 *** Makeinfo is missing or too old.
893 *** Info documentation will not be built.])
900 # Is pod2man recent enough to regenerate manpages?
901 AC_MSG_CHECKING([for recent Pod::Man])
902 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
904 GENERATED_MANPAGES=generated-manpages
909 AC_SUBST(GENERATED_MANPAGES)
911 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
914 dnl Don't use AC_PROG_LEX; we insist on flex.
915 dnl LEXLIB is not useful in gcc.
916 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
919 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
921 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
922 # check for build == host before using them.
925 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
926 && test -d ../binutils ; then
927 NM='${objdir}/../binutils/nm-new'
929 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
933 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
934 && test -d ../binutils ; then
935 AR='${objdir}/../binutils/ar'
937 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
941 # --------------------
942 # Checks for C headers
943 # --------------------
945 # Need to reject headers which give warnings, so that the -Werror bootstrap
946 # works later. *sigh* This needs to come before all header checks.
954 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
955 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
956 sys/resource.h sys/param.h sys/times.h sys/stat.h \
957 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
959 # Check for thread headers.
960 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
961 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
963 # These tests can't be done till we know if we have limits.h.
967 # ----------------------
968 # Checks for C++ headers
969 # ----------------------
971 dnl Autoconf will give an error in the configure script if there is no
972 dnl C++ preprocessor. Hack to prevent that.
973 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
975 m4_popdef([AC_MSG_ERROR])[]dnl
979 AC_CHECK_HEADERS(unordered_map)
980 AC_CHECK_HEADERS(tr1/unordered_map)
981 AC_CHECK_HEADERS(ext/hash_map)
986 # Dependency checking.
991 AC_CONFIG_COMMANDS([gccdepdir],[
992 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
993 for lang in $subdirs c-family common
995 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
996 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
998 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1006 # These libraries may be used by collect2.
1007 # We may need a special search path to get them linked.
1008 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1010 for libs in '' -lld -lmld \
1011 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1012 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1015 AC_TRY_LINK_FUNC(ldopen,
1016 [gcc_cv_collect2_libs="$libs"; break])
1019 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1020 case $gcc_cv_collect2_libs in
1022 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1024 AC_SUBST(COLLECT2_LIBS)
1026 # When building Ada code on Alpha, we need exc_resume which is usually in
1027 # -lexc. So test for it.
1030 AC_SEARCH_LIBS(exc_resume, exc)
1033 AC_SUBST(GNAT_LIBEXC)
1035 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1038 AC_SEARCH_LIBS(kstat_open, kstat)
1039 EXTRA_GCC_LIBS="$LIBS"
1041 AC_SUBST(EXTRA_GCC_LIBS)
1043 # Some systems put ldexp and frexp in libm instead of libc; assume
1044 # they're both in the same place. jcf-dump needs them.
1047 AC_SEARCH_LIBS(ldexp, m)
1052 # Use <inttypes.h> only if it exists,
1053 # doesn't clash with <sys/types.h>, and declares intmax_t.
1054 AC_MSG_CHECKING(for inttypes.h)
1055 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1056 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1057 [[#include <sys/types.h>
1058 #include <inttypes.h>]],
1059 [[intmax_t i = -1;]])],
1060 [gcc_cv_header_inttypes_h=yes],
1061 [gcc_cv_header_inttypes_h=no])])
1062 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1063 if test $gcc_cv_header_inttypes_h = yes; then
1064 AC_DEFINE(HAVE_INTTYPES_H, 1,
1065 [Define if you have a working <inttypes.h> header file.])
1068 dnl Disabled until we have a complete test for buggy enum bitfields.
1069 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1071 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1072 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1073 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1074 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1075 putchar_unlocked putc_unlocked)
1076 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1077 sysconf strsignal getrusage nl_langinfo \
1078 gettimeofday mbstowcs wcswidth mmap setlocale \
1079 gcc_UNLOCKED_FUNCS madvise)
1081 if test x$ac_cv_func_mbstowcs = xyes; then
1082 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1083 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1089 [gcc_cv_func_mbstowcs_works=yes],
1090 [gcc_cv_func_mbstowcs_works=no],
1091 [gcc_cv_func_mbstowcs_works=yes])])
1092 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1093 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1094 [Define this macro if mbstowcs does not crash when its
1095 first argument is NULL.])
1099 AC_CHECK_TYPE(ssize_t, int)
1100 AC_CHECK_TYPE(caddr_t, char *)
1102 GCC_AC_FUNC_MMAP_BLACKLIST
1106 # Under VMS, vfork works very differently than on Unix. The standard test
1107 # won't work, and it isn't easily adaptable. It makes more sense to
1109 ac_cv_func_vfork_works=yes
1114 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1115 # iconv() prototype.
1120 # Until we have in-tree GNU iconv:
1122 AC_SUBST(LIBICONV_DEP)
1128 # We will need to find libiberty.h and ansidecl.h
1129 saved_CFLAGS="$CFLAGS"
1130 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1131 saved_CXXFLAGS="$CXXFLAGS"
1132 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1133 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1134 strsignal strstr stpcpy strverscmp \
1135 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1136 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1137 #include "ansidecl.h"
1138 #include "system.h"])
1140 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1141 #include "ansidecl.h"
1143 #ifdef HAVE_SYS_RESOURCE_H
1144 #include <sys/resource.h>
1148 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1149 #include "ansidecl.h"
1151 #ifdef HAVE_SYS_RESOURCE_H
1152 #include <sys/resource.h>
1154 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1155 [Define to `long' if <sys/resource.h> doesn't define.])])
1157 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1158 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1159 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1160 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1161 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1162 #include "ansidecl.h"
1171 gcc_AC_CHECK_DECLS(times, , ,[
1172 #include "ansidecl.h"
1174 #ifdef HAVE_SYS_TIMES_H
1175 #include <sys/times.h>
1179 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1180 #include "ansidecl.h"
1185 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1188 gcc_AC_CHECK_DECLS(madvise, , ,[
1189 #include "ansidecl.h"
1194 # More time-related stuff.
1195 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1196 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1197 #include "ansidecl.h"
1199 #ifdef HAVE_SYS_TIMES_H
1200 #include <sys/times.h>
1202 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1203 if test $ac_cv_struct_tms = yes; then
1204 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1205 [Define if <sys/times.h> defines struct tms.])
1208 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1209 # revisit after autoconf 2.50.
1210 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1211 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1212 #include "ansidecl.h"
1214 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1215 if test $gcc_cv_type_clock_t = yes; then
1216 AC_DEFINE(HAVE_CLOCK_T, 1,
1217 [Define if <time.h> defines clock_t.])
1220 # Check if F_SETLKW is supported by fcntl.
1221 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1222 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1223 #include <fcntl.h>]], [[
1229 return fcntl (1, F_SETLKW, &fl);]])],
1230 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1231 if test $ac_cv_f_setlkw = yes; then
1232 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1233 [Define if F_SETLKW supported by fcntl.])
1236 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1237 CFLAGS="$saved_CFLAGS"
1238 CXXFLAGS="$saved_CXXFLAGS"
1240 # mkdir takes a single argument on some systems.
1241 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1249 # With Setjmp/Longjmp based exception handling.
1250 AC_ARG_ENABLE(sjlj-exceptions,
1251 [AS_HELP_STRING([--enable-sjlj-exceptions],
1252 [arrange to use setjmp/longjmp exception handling])],
1255 if test $enableval != yes; then
1256 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1261 force_sjlj_exceptions=yes],
1264 force_sjlj_exceptions=yes
1268 force_sjlj_exceptions=yes
1272 force_sjlj_exceptions=no
1275 if test $force_sjlj_exceptions = yes; then
1276 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1277 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1278 [Define 0/1 to force the choice for exception handling model.])
1281 # --------------------------------------------------------
1282 # Build, host, and target specific configuration fragments
1283 # --------------------------------------------------------
1285 # Collect build-machine-specific information.
1286 . ${srcdir}/config.build
1288 # Collect host-machine-specific information.
1289 . ${srcdir}/config.host
1293 # Collect target-machine-specific information.
1294 . ${srcdir}/config.gcc
1296 extra_objs="${host_extra_objs} ${extra_objs}"
1297 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1299 # Default the target-machine variables that were not explicitly set.
1300 if test x"$tm_file" = x
1301 then tm_file=$cpu_type/$cpu_type.h; fi
1303 if test x"$extra_headers" = x
1304 then extra_headers=; fi
1306 if test x$md_file = x
1307 then md_file=$cpu_type/$cpu_type.md; fi
1309 if test x$out_file = x
1310 then out_file=$cpu_type/$cpu_type.c; fi
1312 if test x"$tmake_file" = x
1313 then tmake_file=$cpu_type/t-$cpu_type
1316 # Support --enable-initfini-array.
1317 if test x$enable_initfini_array != xno; then
1318 tm_file="${tm_file} initfini-array.h"
1321 if test x"$dwarf2" = xyes
1322 then tm_file="$tm_file tm-dwarf2.h"
1325 # Say what files are being used for the output code and MD file.
1326 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1327 echo "Using \`$srcdir/config/$md_file' as machine description file."
1329 # If any of the xm_file variables contain nonexistent files, warn
1330 # about them and drop them.
1333 for x in $build_xm_file; do
1334 if test -f $srcdir/config/$x
1336 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1342 for x in $host_xm_file; do
1343 if test -f $srcdir/config/$x
1345 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1351 for x in $xm_file; do
1352 if test -f $srcdir/config/$x
1354 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1360 for f in $tm_file; do
1363 if test $count = ax; then
1364 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1366 echo "Using the following target machine macro files:"
1367 for f in $tm_file; do
1368 echo " $srcdir/config/$f"
1372 if test x$need_64bit_hwint = xyes; then
1373 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1374 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1377 if test x$use_long_long_for_widest_fast_int = xyes; then
1378 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1379 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1380 efficiently supported by the host hardware.])
1383 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1384 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1386 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1387 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1390 for f in $host_xm_file; do
1393 if test $count = a; then
1395 elif test $count = ax; then
1396 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1398 echo "Using the following host machine macro files:"
1399 for f in $host_xm_file; do
1400 echo " $srcdir/config/$f"
1403 echo "Using ${out_host_hook_obj} for host machine hooks."
1405 if test "$host_xm_file" != "$build_xm_file"; then
1407 for f in $build_xm_file; do
1410 if test $count = a; then
1412 elif test $count = ax; then
1413 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1415 echo "Using the following build machine macro files:"
1416 for f in $build_xm_file; do
1417 echo " $srcdir/config/$f"
1422 if test -n "$configured_native_system_header_dir"; then
1423 native_system_header_dir=$configured_native_system_header_dir
1425 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1426 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1430 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1431 gcc_cv_mcontext_underscores,
1433 #include <sys/cdefs.h>
1434 #include <sys/signal.h>
1435 #include <ucontext.h>
1436 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1438 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1439 if test $gcc_cv_mcontext_underscores = yes; then
1440 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1441 [mcontext_t fields start with __])
1450 # Check if a valid thread package
1451 case ${enable_threads} in
1454 target_thread_file='single'
1458 target_thread_file='single'
1460 aix | dce | lynx | mipssde | posix | rtems | \
1461 single | tpf | vxworks | win32)
1462 target_thread_file=${enable_threads}
1465 echo "${enable_threads} is an unknown thread package" 1>&2
1470 if test x${thread_file} = x; then
1471 # No thread file set by target-specific clauses in config.gcc,
1472 # so use file chosen by default logic above
1473 thread_file=${target_thread_file}
1481 if test x$enable___cxa_atexit = xyes || \
1482 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1483 if test x$host = x$target; then
1485 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1486 # keyed to flag_use_cxa_atexit
1494 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1495 [echo "__cxa_atexit can't be enabled on this target"])
1499 # We can't check for __cxa_atexit when building a cross, so assume
1503 if test x$use_cxa_atexit = xyes; then
1504 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1505 [Define if you want to use __cxa_atexit, rather than atexit, to
1506 register C++ destructors for local statics and global objects.
1507 This is essential for fully standards-compliant handling of
1508 destructors, but requires __cxa_atexit in libc.])
1512 # Look for a file containing extra machine modes.
1513 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1514 extra_modes_file='$(srcdir)'/config/${extra_modes}
1515 AC_SUBST(extra_modes_file)
1516 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1517 [Define to the name of a file containing a list of extra machine modes
1518 for this architecture.])
1521 # Convert extra_options into a form suitable for Makefile use.
1524 for f in $extra_options; do
1525 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1526 all_opt_files="$all_opt_files $srcdir/config/$f"
1528 AC_SUBST(extra_opt_files)
1530 # auto-host.h is the file containing items generated by autoconf and is
1531 # the first file included by config.h.
1532 # If host=build, it is correct to have bconfig include auto-host.h
1533 # as well. If host!=build, we are in error and need to do more
1534 # work to find out the build config parameters.
1535 if test x$host = x$build
1537 build_auto=auto-host.h
1539 # We create a subdir, then run autoconf in the subdir.
1540 # To prevent recursion we set host and build for the new
1541 # invocation of configure to the build for this invocation
1548 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1549 *) realsrcdir=../${srcdir};;
1551 # Clearing GMPINC is necessary to prevent host headers being
1552 # used by the build compiler. Defining GENERATOR_FILE stops
1553 # system.h from including gmp.h.
1554 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1555 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1556 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1557 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1558 ${realsrcdir}/configure \
1559 --enable-languages=${enable_languages-all} \
1560 --target=$target_alias --host=$build_alias --build=$build_alias
1562 # We just finished tests for the build machine, so rename
1563 # the file auto-build.h in the gcc directory.
1564 mv auto-host.h ../auto-build.h
1567 build_auto=auto-build.h
1569 AC_SUBST(build_subdir)
1571 tm_file="${tm_file} defaults.h"
1572 tm_p_file="${tm_p_file} tm-preds.h"
1573 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1574 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1575 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1576 # put this back in temporarily.
1577 xm_file="auto-host.h ansidecl.h ${xm_file}"
1584 # Compile in configure arguments.
1585 if test -f configargs.h ; then
1586 # Being re-configured.
1587 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1588 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1590 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1593 # Double all backslashes and backslash all quotes to turn
1594 # gcc_config_arguments into a C string.
1595 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1596 $gcc_config_arguments
1598 gcc_config_arguments_str=`cat conftest.out`
1601 cat > configargs.h <<EOF
1602 /* Generated automatically. */
1603 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1604 static const char thread_model[] = "$thread_file";
1606 static const struct {
1607 const char *name, *value;
1608 } configure_default_options[] = $configure_default_options;
1613 gcc_BASEVER=`cat $srcdir/BASE-VER`
1614 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1615 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1616 if test -f $srcdir/REVISION ; then
1617 gcc_REVISION=`cat $srcdir/REVISION`
1621 cat > plugin-version.h <<EOF
1622 #include "configargs.h"
1624 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1625 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1626 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1627 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1629 static char basever[] = "$gcc_BASEVER";
1630 static char datestamp[] = "$gcc_DATESTAMP";
1631 static char devphase[] = "$gcc_DEVPHASE";
1632 static char revision[] = "$gcc_REVISION";
1634 /* FIXME plugins: We should make the version information more precise.
1635 One way to do is to add a checksum. */
1637 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1639 configuration_arguments};
1643 # Internationalization
1644 ZW_GNU_GETTEXT_SISTER_DIR
1646 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1647 # -liconv on the link line twice.
1648 case "$LIBINTL" in *$LIBICONV*)
1652 AC_ARG_ENABLE(secureplt,
1653 [AS_HELP_STRING([--enable-secureplt],
1654 [enable -msecure-plt by default for PowerPC])],
1657 AC_ARG_ENABLE(leading-mingw64-underscores,
1658 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1659 [enable leading underscores on 64 bit mingw targets]),
1661 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1662 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1663 [Define if we should use leading underscore on 64 bit mingw targets])])
1666 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1669 AC_ARG_ENABLE(frame-pointer,
1670 [AS_HELP_STRING([--enable-frame-pointer],
1671 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1674 linux* | darwin[[8912]]*)
1675 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1677 enable_frame_pointer=no
1680 enable_frame_pointer=yes
1685 # Windows32 Registry support for specifying GCC installation paths.
1686 AC_ARG_ENABLE(win32-registry,
1687 [AS_HELP_STRING([--disable-win32-registry],
1688 [disable lookup of installation paths in the
1689 Registry on Windows hosts])
1690 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1691 AS_HELP_STRING([--enable-win32-registry=KEY],
1692 [use KEY instead of GCC version as the last portion
1693 of the registry key])],,)
1696 win32 | pe | cygwin* | mingw32* | uwin*)
1697 if test "x$enable_win32_registry" != xno; then
1698 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1701 if test "x$enable_win32_registry" != xno; then
1702 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1703 [Define to 1 if installation paths should be looked up in the Windows
1704 Registry. Ignored on non-Windows hosts.])
1706 if test "x$enable_win32_registry" != xyes \
1707 && test "x$enable_win32_registry" != x; then
1708 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1709 [Define to be the last component of the Windows registry key under which
1710 to look for installation paths. The full key used will be
1711 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1712 The default is the GCC version number.])
1718 # Get an absolute path to the GCC top-level source directory
1719 holddir=`${PWDCMD-pwd}`
1721 topdir=`${PWDCMD-pwd}`
1724 # Conditionalize the makefile for this host machine.
1726 for f in ${host_xmake_file}
1728 if test -f ${srcdir}/config/$f
1730 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1734 # Conditionalize the makefile for this target machine.
1736 for f in ${tmake_file}
1738 if test -f ${srcdir}/config/$f
1740 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1743 tmake_file="${tmake_file_}"
1745 out_object_file=`basename $out_file .c`.o
1746 common_out_object_file=`basename $common_out_file .c`.o
1748 tm_file_list="options.h"
1749 tm_include_list="options.h insn-constants.h"
1750 for f in $tm_file; do
1753 f=`echo $f | sed 's/^..//'`
1754 tm_file_list="${tm_file_list} $f"
1755 tm_include_list="${tm_include_list} $f"
1758 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1759 tm_include_list="${tm_include_list} $f"
1762 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1763 tm_include_list="${tm_include_list} config/$f"
1770 for f in $tm_p_file; do
1773 tm_p_file_list="${tm_p_file_list} $f"
1774 tm_p_include_list="${tm_p_include_list} $f"
1777 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1778 tm_p_include_list="${tm_p_include_list} config/$f"
1784 for f in $xm_file; do
1787 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1788 xm_include_list="${xm_include_list} $f"
1791 xm_file_list="${xm_file_list} $f"
1792 xm_include_list="${xm_include_list} $f"
1795 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1796 xm_include_list="${xm_include_list} config/$f"
1802 host_xm_include_list=
1803 for f in $host_xm_file; do
1806 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1807 host_xm_include_list="${host_xm_include_list} $f"
1810 host_xm_file_list="${host_xm_file_list} $f"
1811 host_xm_include_list="${host_xm_include_list} $f"
1814 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1815 host_xm_include_list="${host_xm_include_list} config/$f"
1821 for f in $build_xm_file; do
1824 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1825 build_xm_include_list="${build_xm_include_list} $f"
1827 auto-build.h | auto-host.h )
1828 build_xm_file_list="${build_xm_file_list} $f"
1829 build_xm_include_list="${build_xm_include_list} $f"
1832 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1833 build_xm_include_list="${build_xm_include_list} config/$f"
1838 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1839 # cross-compiler which does not use the native headers and libraries.
1840 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1841 CROSS= AC_SUBST(CROSS)
1842 ALL=all.internal AC_SUBST(ALL)
1843 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1845 if test "x$with_build_sysroot" != x; then
1846 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1848 # This value is used, even on a native system, because
1849 # CROSS_SYSTEM_HEADER_DIR is just
1850 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1851 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1854 if test x$host != x$target
1856 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1858 SYSTEM_HEADER_DIR=$build_system_header_dir
1859 case "$host","$target" in
1860 # Darwin crosses can use the host system's libraries and headers,
1861 # because of the fat library support. Of course, it must be the
1862 # same version of Darwin on both sides. Allow the user to
1863 # just say --target=foo-darwin without a version number to mean
1864 # "the version on this system".
1865 *-*-darwin*,*-*-darwin*)
1866 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1867 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1868 if test $hostos = $targetos -o $targetos = darwin ; then
1870 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1875 i?86-*-*,x86_64-*-* \
1876 | powerpc*-*-*,powerpc64*-*-*)
1877 CROSS="$CROSS -DNATIVE_CROSS" ;;
1882 if test "x$with_headers" = x; then
1889 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1890 SYSTEM_HEADER_DIR=$build_system_header_dir
1893 # If this is a cross-compiler that does not
1894 # have its own set of headers then define
1897 # If this is using newlib, without having the headers available now,
1898 # then define inhibit_libc in LIBGCC2_CFLAGS.
1899 # This prevents libgcc2 from containing any code which requires libc
1901 : ${inhibit_libc=false}
1902 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1903 test x$with_newlib = xyes ; } &&
1904 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1907 AC_SUBST(inhibit_libc)
1909 # When building gcc with a cross-compiler, we need to adjust things so
1910 # that the generator programs are still built with the native compiler.
1911 # Also, we cannot run fixincludes.
1913 # These are the normal (build=host) settings:
1914 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1915 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
1916 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1917 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
1918 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
1919 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1921 # And these apply if build != host, or we are generating coverage data
1922 if test x$build != x$host || test "x$coverage_flags" != x
1924 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1925 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
1926 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1929 # Expand extra_headers to include complete path.
1930 # This substitutes for lots of t-* files.
1932 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1933 for file in ${extra_headers} ; do
1934 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1937 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1938 if test x"$use_gcc_tgmath" = xyes
1939 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1942 # Define collect2 in Makefile.
1943 case $host_can_use_collect2 in
1945 *) collect2='collect2$(exeext)' ;;
1947 AC_SUBST([collect2])
1949 # Add a definition of USE_COLLECT2 if system wants one.
1950 case $use_collect2 in
1951 no) use_collect2= ;;
1954 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1955 xm_defines="${xm_defines} USE_COLLECT2"
1956 case $host_can_use_collect2 in
1958 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1964 AC_DEFINE_UNQUOTED(FRPLUGINSONAME,"${host_function_reordering_plugin_soname}",
1965 [Define to the name of the function reordering plugin DSO that must be
1966 passed to the linker's -plugin=LIB option.])
1968 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
1969 [Define to the name of the LTO plugin DSO that must be
1970 passed to the linker's -plugin=LIB option.])
1972 # ---------------------------
1973 # Assembler & linker features
1974 # ---------------------------
1976 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1977 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1978 # However when ld-new is first executed from the build tree, libtool will
1979 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1980 # to the build tree. While doing this we need to use the previous-stage
1981 # linker, or we have an infinite loop. The presence of a shell script as
1982 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1983 # the gcc/collect-ld script. So we need to know how libtool works, or
1984 # exec-tool will fail.
1986 m4_defun([_LT_CONFIG_COMMANDS], [])
1989 AC_SUBST(enable_fast_install)
1991 # Identify the assembler which will work hand-in-glove with the newly
1992 # built GCC, so that we can examine its features. This is the assembler
1993 # which will be driven by the driver program.
1995 # If build != host, and we aren't building gas in-tree, we identify a
1996 # build->target assembler and hope that it will have the same features
1997 # as the host->target assembler we'll be using.
1998 gcc_cv_gas_major_version=
1999 gcc_cv_gas_minor_version=
2000 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2002 m4_pattern_allow([AS_FOR_TARGET])dnl
2003 AS_VAR_SET_IF(gcc_cv_as,, [
2004 if test -x "$DEFAULT_ASSEMBLER"; then
2005 gcc_cv_as="$DEFAULT_ASSEMBLER"
2006 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2007 && test -f ../gas/Makefile \
2008 && test x$build = x$host; then
2009 gcc_cv_as=../gas/as-new$build_exeext
2010 elif test -x as$build_exeext; then
2011 # Build using assembler in the current directory.
2012 gcc_cv_as=./as$build_exeext
2013 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2014 gcc_cv_as="$AS_FOR_TARGET"
2016 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2019 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2020 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2021 case "$ORIGINAL_AS_FOR_TARGET" in
2022 ./as | ./as$build_exeext) ;;
2023 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2026 AC_MSG_CHECKING(what assembler to use)
2027 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2028 # Single tree build which includes gas. We want to prefer it
2029 # over whatever linker top-level may have detected, since
2030 # we'll use what we're building after installation anyway.
2031 AC_MSG_RESULT(newly built gas)
2033 _gcc_COMPUTE_GAS_VERSION
2034 in_tree_gas_is_elf=no
2035 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2036 || (grep 'obj_format = multi' ../gas/Makefile \
2037 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2039 in_tree_gas_is_elf=yes
2042 AC_MSG_RESULT($gcc_cv_as)
2048 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2049 [case "${enableval}" in
2056 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2057 [case "${enableval}" in
2059 install_gold_as_default=yes
2062 if test x${default_ld} != x; then
2063 install_gold_as_default=yes
2069 AC_MSG_ERROR([invalid --enable-gold argument])
2072 [install_gold_as_default=no])
2074 # Identify the linker which will work hand-in-glove with the newly
2075 # built GCC, so that we can examine its features. This is the linker
2076 # which will be driven by the driver program.
2078 # If build != host, and we aren't building gas in-tree, we identify a
2079 # build->target linker and hope that it will have the same features
2080 # as the host->target linker we'll be using.
2081 gcc_cv_gld_major_version=
2082 gcc_cv_gld_minor_version=
2083 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2084 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2085 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2087 AS_VAR_SET_IF(gcc_cv_ld,, [
2088 if test -x "$DEFAULT_LINKER"; then
2089 gcc_cv_ld="$DEFAULT_LINKER"
2090 elif test $install_gold_as_default = yes \
2091 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2092 && test -f ../gold/Makefile \
2093 && test x$build = x$host; then
2094 gcc_cv_ld=../gold/ld-new$build_exeext
2095 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2096 && test -f ../ld/Makefile \
2097 && test x$build = x$host; then
2098 gcc_cv_ld=../ld/ld-new$build_exeext
2099 elif test -x collect-ld$build_exeext; then
2100 # Build using linker in the current directory.
2101 gcc_cv_ld=./collect-ld$build_exeext
2102 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2103 gcc_cv_ld="$LD_FOR_TARGET"
2105 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2108 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2109 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2110 # if the PLUGIN_LD is set ld-new, just have it as ld
2111 # as that is the installed named.
2112 if test x$PLUGIN_LD_SUFFIX = xld-new \
2113 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2116 AC_ARG_WITH(plugin-ld,
2117 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2118 [if test x"$withval" != x; then
2119 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2120 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2122 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2123 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2125 # Check to see if we are using gold instead of ld
2126 AC_MSG_CHECKING(whether we are using gold)
2128 if test x$gcc_cv_ld != x; then
2129 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2130 | grep "GNU gold" > /dev/null; then
2134 AC_MSG_RESULT($ld_is_gold)
2136 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2137 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2138 case "$ORIGINAL_LD_FOR_TARGET" in
2139 ./collect-ld | ./collect-ld$build_exeext) ;;
2140 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2143 AC_MSG_CHECKING(what linker to use)
2144 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2145 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2146 # Single tree build which includes ld. We want to prefer it
2147 # over whatever linker top-level may have detected, since
2148 # we'll use what we're building after installation anyway.
2149 AC_MSG_RESULT(newly built ld)
2151 in_tree_ld_is_elf=no
2152 if (grep 'EMUL = .*elf' ../ld/Makefile \
2153 || grep 'EMUL = .*linux' ../ld/Makefile \
2154 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2155 in_tree_ld_is_elf=yes
2156 elif test "$ld_is_gold" = yes; then
2157 in_tree_ld_is_elf=yes
2159 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
2162 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2163 if test x$gcc_cv_gld_version != x; then
2167 case $gcc_cv_gld_version in
2170 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2173 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2174 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2176 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2177 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2179 AC_MSG_RESULT($gcc_cv_ld)
2181 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2182 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2183 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2186 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2187 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2189 # Figure out what nm we will be using.
2190 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2191 AS_VAR_SET_IF(gcc_cv_nm,, [
2192 if test -f $gcc_cv_binutils_srcdir/configure.in \
2193 && test -f ../binutils/Makefile \
2194 && test x$build = x$host; then
2195 gcc_cv_nm=../binutils/nm-new$build_exeext
2196 elif test -x nm$build_exeext; then
2197 gcc_cv_nm=./nm$build_exeext
2198 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2199 gcc_cv_nm="$NM_FOR_TARGET"
2201 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2204 AC_MSG_CHECKING(what nm to use)
2205 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2206 # Single tree build which includes binutils.
2207 AC_MSG_RESULT(newly built nm)
2210 AC_MSG_RESULT($gcc_cv_nm)
2214 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2215 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2216 case "$ORIGINAL_NM_FOR_TARGET" in
2217 ./nm | ./nm$build_exeext) ;;
2218 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2222 # Figure out what objdump we will be using.
2223 AS_VAR_SET_IF(gcc_cv_objdump,, [
2224 if test -f $gcc_cv_binutils_srcdir/configure.in \
2225 && test -f ../binutils/Makefile \
2226 && test x$build = x$host; then
2227 # Single tree build which includes binutils.
2228 gcc_cv_objdump=../binutils/objdump$build_exeext
2229 elif test -x objdump$build_exeext; then
2230 gcc_cv_objdump=./objdump$build_exeext
2231 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2232 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2234 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2237 AC_MSG_CHECKING(what objdump to use)
2238 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2239 # Single tree build which includes binutils.
2240 AC_MSG_RESULT(newly built objdump)
2241 elif test x$gcc_cv_objdump = x; then
2242 AC_MSG_RESULT(not found)
2244 AC_MSG_RESULT($gcc_cv_objdump)
2247 # Figure out what readelf we will be using.
2248 AS_VAR_SET_IF(gcc_cv_readelf,, [
2249 if test -f $gcc_cv_binutils_srcdir/configure.in \
2250 && test -f ../binutils/Makefile \
2251 && test x$build = x$host; then
2252 # Single tree build which includes binutils.
2253 gcc_cv_readelf=../binutils/readelf$build_exeext
2254 elif test -x readelf$build_exeext; then
2255 gcc_cv_readelf=./readelf$build_exeext
2256 elif ( set dummy $READELF_FOR_TARGET; test -x $[2] ); then
2257 gcc_cv_readelf="$READELF_FOR_TARGET"
2259 AC_PATH_PROG(gcc_cv_readelf, $READELF_FOR_TARGET)
2262 AC_MSG_CHECKING(what readelf to use)
2263 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2264 # Single tree build which includes binutils.
2265 AC_MSG_RESULT(newly built readelf)
2266 elif test x$gcc_cv_readelf = x; then
2267 AC_MSG_RESULT(not found)
2269 AC_MSG_RESULT($gcc_cv_readelf)
2272 # Figure out what assembler alignment features are present.
2273 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2277 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2278 [Define if your assembler supports .balign and .p2align.])])
2280 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2283 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2284 [Define if your assembler supports specifying the maximum number
2285 of bytes to skip when using the GAS .p2align command.])])
2287 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2290 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2291 [Define if your assembler supports .literal16.])])
2293 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2295 [conftest_label1: .word 0
2297 conftest_label2: .word 0
2299 [if test x$gcc_cv_nm != x; then
2300 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2301 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2302 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2304 else gcc_cv_as_subsection_m1=yes
2306 rm -f conftest.nm1 conftest.nm2
2308 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2309 [Define if your assembler supports .subsection and .subsection -1 starts
2310 emitting at the beginning of your section.])])
2312 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2315 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2317 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2319 [ .weakref foobar, barfnot],,
2320 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2322 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2325 .NSUBSPA $CODE$,COMDAT],,
2326 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2328 # .hidden needs to be supported in both the assembler and the linker,
2329 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2330 # This is irritatingly difficult to feature test for; we have to check the
2331 # date string after the version number. If we've got an in-tree
2332 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2334 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2335 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2339 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2340 # STV_HIDDEN, so disable .hidden support if so.
2342 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2343 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2344 cat > conftest.s <<EOF
2351 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2352 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2353 grep '\.hidden default' > /dev/null; then
2356 gcc_cv_as_hidden=yes
2359 # Assume bug is present if objdump is missing.
2364 gcc_cv_as_hidden=yes
2369 # Darwin as has some visibility support, though with a different syntax.
2370 gcc_cv_as_hidden=yes
2374 # gnu_indirect_function type is an extension proposed at
2375 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2376 # selection of function implementation
2377 AC_ARG_ENABLE(gnu-indirect-function,
2378 [AS_HELP_STRING([--enable-gnu-indirect-function],
2379 [enable the use of the @gnu_indirect_function to glibc systems])],
2380 [case $enable_gnu_indirect_function in
2382 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2383 Valid choices are 'yes' and 'no'.]) ;;
2385 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2387 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2388 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2389 [Define if your system supports gnu indirect functions.])
2393 if test $in_tree_ld != yes ; then
2394 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2395 if echo "$ld_ver" | grep GNU > /dev/null; then
2396 if test x"$ld_is_gold" = xyes; then
2397 # GNU gold --version looks like this:
2399 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2401 # We extract the binutils version which is more familiar and specific
2402 # than the gold version.
2403 ld_vers=`echo $ld_ver | sed -n \
2404 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2406 # GNU ld --version looks like this:
2408 # GNU ld (GNU Binutils) 2.21.51.20110225
2409 ld_vers=`echo $ld_ver | sed -n \
2410 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2412 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'`
2413 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2414 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2415 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2419 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2422 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2423 # /usr/ccs/bin/ld has been configured.
2424 ld_ver=`$gcc_cv_ld -V 2>&1`
2425 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2426 ld_vers=`echo $ld_ver | sed -n \
2427 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2428 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2429 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2437 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2438 [[if test $in_tree_ld = yes ; then
2440 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 \
2441 && test $in_tree_ld_is_elf = yes; then
2442 gcc_cv_ld_hidden=yes
2445 gcc_cv_ld_hidden=yes
2446 if test x"$ld_is_gold" = xyes; then
2448 elif echo "$ld_ver" | grep GNU > /dev/null; then
2450 mmix-knuth-mmixware)
2451 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2455 if test 0"$ld_date" -lt 20020404; then
2456 if test -n "$ld_date"; then
2457 # If there was date string, but was earlier than 2002-04-04, fail
2459 elif test -z "$ld_vers"; then
2460 # If there was no date string nor ld version number, something is wrong
2463 test -z "$ld_vers_patch" && ld_vers_patch=0
2464 if test "$ld_vers_major" -lt 2; then
2466 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2467 gcc_cv_ld_hidden="no"
2468 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2476 # Darwin ld has some visibility support.
2477 gcc_cv_ld_hidden=yes
2479 hppa64*-*-hpux* | ia64*-*-hpux*)
2480 gcc_cv_ld_hidden=yes
2482 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2483 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2484 # .symbolic was only added in Solaris 9 12/02.
2485 gcc_cv_ld_hidden=yes
2493 libgcc_visibility=no
2494 AC_SUBST(libgcc_visibility)
2495 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2496 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2497 libgcc_visibility=yes
2498 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2499 [Define if your assembler and linker support .hidden.])
2502 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2503 gcc_cv_ld_ro_rw_mix=unknown
2504 if test $in_tree_ld = yes ; then
2505 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 \
2506 && test $in_tree_ld_is_elf = yes; then
2507 gcc_cv_ld_ro_rw_mix=read-write
2509 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2510 echo '.section myfoosect, "a"' > conftest1.s
2511 echo '.section myfoosect, "aw"' > conftest2.s
2512 echo '.byte 1' >> conftest2.s
2513 echo '.section myfoosect, "a"' > conftest3.s
2514 echo '.byte 0' >> conftest3.s
2515 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2516 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2517 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2518 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2519 conftest2.o conftest3.o > /dev/null 2>&1; then
2520 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2521 | sed -e '/myfoosect/!d' -e N`
2522 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2523 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2524 gcc_cv_ld_ro_rw_mix=read-only
2526 gcc_cv_ld_ro_rw_mix=read-write
2531 rm -f conftest.* conftest[123].*
2534 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2535 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2536 [Define if your linker links a mix of read-only
2537 and read-write sections into a read-write section.])
2539 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2541 gcc_AC_INITFINI_ARRAY
2543 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2544 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2552 [[# GAS versions before 2.11 do not support uleb128,
2553 # despite appearing to.
2554 # ??? There exists an elf-specific test that will crash
2555 # the assembler. Perhaps it's better to figure out whether
2556 # arbitrary sections are supported and try the test.
2557 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2558 if echo "$as_ver" | grep GNU > /dev/null; then
2559 as_vers=`echo $as_ver | sed -n \
2560 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2561 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2562 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2563 if test $as_major -eq 2 && test $as_minor -lt 11
2565 else gcc_cv_as_leb128=yes
2568 [AC_DEFINE(HAVE_AS_LEB128, 1,
2569 [Define if your assembler supports .sleb128 and .uleb128.])])
2571 # Check if we have assembler support for unwind directives.
2572 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2579 .cfi_escape 1, 2, 3, 4, 5
2583 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2584 # read-only and read-write sections, we need to make sure that the
2585 # assembler used emits read-write .eh_frame sections.
2586 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2587 if test "x$gcc_cv_objdump" != x; then
2588 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2589 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2590 gcc_cv_as_cfi_directive=no
2593 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2594 # On Solaris/x86, make sure that GCC and gas agree on using
2595 # read-only .eh_frame sections for 64-bit.
2596 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2597 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2598 sed -e /.eh_frame/!d -e N | \
2599 grep READONLY > /dev/null; then
2600 gcc_cv_as_cfi_directive=yes
2602 gcc_cv_as_cfi_directive=no
2606 gcc_cv_as_cfi_directive=yes
2611 # no objdump, err on the side of caution
2612 gcc_cv_as_cfi_directive=no
2615 gcc_cv_as_cfi_directive=yes
2619 gcc_cv_as_cfi_directive=yes
2622 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2623 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2627 .cfi_adjust_cfa_offset 64
2629 .cfi_adjust_cfa_offset 128
2632 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2633 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2634 gcc_cv_as_cfi_advance_working=yes
2638 # no objdump, err on the side of caution
2639 gcc_cv_as_cfi_advance_working=no
2641 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2642 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2643 [`if test $gcc_cv_as_cfi_directive = yes \
2644 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2645 [Define 0/1 if your assembler supports CFI directives.])
2647 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2648 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2649 gcc_cv_as_cfi_personality_directive, ,,
2652 .cfi_personality 0, symbol
2654 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2655 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2656 then echo 1; else echo 0; fi`],
2657 [Define 0/1 if your assembler supports .cfi_personality.])
2659 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2660 gcc_cv_as_cfi_sections_directive, ,,
2662 .cfi_sections .debug_frame, .eh_frame
2666 win32 | pe | cygwin* | mingw32* | uwin*)
2667 # Need to check that we generated the correct relocation for the
2668 # .debug_frame section. This was fixed for binutils 2.21.
2669 gcc_cv_as_cfi_sections_directive=no
2670 if test "x$gcc_cv_objdump" != x; then
2671 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2672 grep secrel > /dev/null; then
2673 gcc_cv_as_cfi_sections_directive=yes
2678 gcc_cv_as_cfi_sections_directive=yes
2681 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2682 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2683 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2684 then echo 1; else echo 0; fi`],
2685 [Define 0/1 if your assembler supports .cfi_sections.])
2687 # GAS versions up to and including 2.11.0 may mis-optimize
2689 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2697 .section .eh_frame,"aw",@progbits
2699 .4byte .LECIE1-.LSCIE1
2713 .4byte .LEFDE1-.LASFDE1
2715 .4byte .LASFDE1-__FRAME_BEGIN__
2723 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2724 cat > conftest.lit <<EOF
2725 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2726 0010 01000000 12000000 18000000 00000000 ................
2727 0020 08000000 04080000 0044 .........D @&t@
2729 cat > conftest.big <<EOF
2730 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2731 0010 00000001 00000012 00000018 00000000 ................
2732 0020 00000008 04000000 0844 .........D @&t@
2734 # If the assembler didn't choke, and we can objdump,
2735 # and we got the correct data, then succeed.
2736 # The text in the here-document typically retains its unix-style line
2737 # endings, while the output of objdump will use host line endings.
2738 # Therefore, use diff -b for the comparisons.
2739 if test x$gcc_cv_objdump != x \
2740 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2741 | tail -3 > conftest.got \
2742 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2743 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2745 gcc_cv_as_eh_frame=yes
2746 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2747 gcc_cv_as_eh_frame=buggy
2749 # Uh oh, what do we do now?
2750 gcc_cv_as_eh_frame=no
2753 if test $gcc_cv_as_eh_frame = buggy; then
2754 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2755 [Define if your assembler mis-optimizes .eh_frame data.])
2758 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2759 [elf,2,12,0], [--fatal-warnings],
2760 [.section .rodata.str, "aMS", @progbits, 1])
2761 if test $gcc_cv_as_shf_merge = no; then
2762 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2763 [elf,2,12,0], [--fatal-warnings],
2764 [.section .rodata.str, "aMS", %progbits, 1])
2766 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2767 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2768 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2770 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2771 gcc_cv_as_comdat_group,
2772 [elf,2,16,0], [--fatal-warnings],
2773 [.section .text,"axG",@progbits,.foo,comdat])
2774 if test $gcc_cv_as_comdat_group = yes; then
2775 gcc_cv_as_comdat_group_percent=no
2776 gcc_cv_as_comdat_group_group=no
2778 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2779 gcc_cv_as_comdat_group_percent,
2780 [elf,2,16,0], [--fatal-warnings],
2781 [.section .text,"axG",%progbits,.foo,comdat])
2782 if test $gcc_cv_as_comdat_group_percent = yes; then
2783 gcc_cv_as_comdat_group_group=no
2785 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2786 gcc_cv_as_comdat_group_group=no
2789 # Sun as uses a completely different syntax.
2794 .group foo,".text%foo",#comdat
2795 .section ".text%foo", #alloc,#execinstr,#progbits
2800 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2802 .group foo,.text%foo,#comdat
2803 .section .text%foo, "ax", @progbits
2809 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2810 gcc_cv_as_comdat_group_group,
2816 if test x"$ld_is_gold" = xyes; then
2818 elif test $in_tree_ld = yes ; then
2820 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 \
2821 && test $in_tree_ld_is_elf = yes; then
2824 elif echo "$ld_ver" | grep GNU > /dev/null; then
2826 if test 0"$ld_date" -lt 20050308; then
2827 if test -n "$ld_date"; then
2828 # If there was date string, but was earlier than 2005-03-08, fail
2830 elif test "$ld_vers_major" -lt 2; then
2832 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2839 *-*-solaris2.1[1-9]*)
2841 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2842 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2845 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2846 # least ld version 1.2267.
2847 if test "$ld_vers_major" -gt 1; then
2849 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2851 elif test "$ld_vers_minor" -ge 2267; then
2856 # Assume linkers other than GNU ld don't support COMDAT group.
2862 # Allow overriding the automatic COMDAT group tests above.
2863 AC_ARG_ENABLE(comdat,
2864 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2865 [comdat_group="$enable_comdat"])
2866 if test $comdat_group = no; then
2867 gcc_cv_as_comdat_group=no
2868 gcc_cv_as_comdat_group_percent=no
2869 gcc_cv_as_comdat_group_group=no
2871 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2872 [`if test $gcc_cv_as_comdat_group = yes \
2873 || test $gcc_cv_as_comdat_group_percent = yes \
2874 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2875 [Define 0/1 if your assembler and linker support COMDAT groups.])
2877 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2878 gcc_cv_as_discriminator,
2882 .loc 1 1 0 discriminator 1],,
2883 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2884 [Define if your assembler supports the .loc discriminator sub-directive.])])
2886 # Thread-local storage - the check is heavily parameterized.
2895 .section ".tdata","awT",@progbits
2898 ldq $27,__tls_get_addr($29) !literal!1
2899 lda $16,foo($29) !tlsgd!1
2900 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2901 ldq $27,__tls_get_addr($29) !literal!2
2902 lda $16,foo($29) !tlsldm!2
2903 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2904 ldq $1,foo($29) !gotdtprel
2905 ldah $2,foo($29) !dtprelhi
2906 lda $3,foo($2) !dtprello
2907 lda $4,foo($29) !dtprel
2908 ldq $1,foo($29) !gottprel
2909 ldah $2,foo($29) !tprelhi
2910 lda $3,foo($2) !tprello
2911 lda $4,foo($29) !tprel'
2914 tls_as_opt=--fatal-warnings
2916 cris-*-*|crisv32-*-*)
2918 .section ".tdata","awT",@progbits
2925 tls_as_opt=--fatal-warnings
2929 .section ".tdata","awT",@progbits
2941 .section ".tdata","awT",@progbits
2945 addil LT%foo-$tls_gdidx$,gp
2946 ldo RT%foo-$tls_gdidx$(%r1),%arg0
2949 addil LT%foo-$tls_ldidx$,gp
2951 ldo RT%foo-$tls_ldidx$(%r1),%arg0
2952 addil LR%foo-$tls_dtpoff$,%ret0
2953 ldo RR%foo-$tls_dtpoff$(%r1),%t1
2955 addil LT%foo-$tls_ieoff$,gp
2956 ldw RT%foo-$tls_ieoff$(%r1),%t2
2959 addil LR%foo-$tls_leoff$,%t1
2960 ldo RR%foo-$tls_leoff$(%r1),%t2'
2963 tls_as_opt=--fatal-warnings
2967 .section ".tdata","awT",%progbits
2978 i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
2980 i[34567]86-*-solaris2.*)
2982 tga_func=___tls_get_addr
2984 x86_64-*-solaris2.1[0-9]*)
2986 tga_func=__tls_get_addr
2992 if test x$on_solaris = xyes && test x$gas_flag = xno; then
2994 .section .tdata,"awt",@progbits'
2999 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3000 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3004 .section ".tdata","awT",@progbits'
3008 tls_as_opt="--fatal-warnings"
3010 conftest_s="$conftest_s
3014 leal foo@tlsgd(,%ebx,1), %eax
3015 leal foo@tlsldm(%ebx), %eax
3016 leal foo@dtpoff(%eax), %edx
3017 movl foo@gottpoff(%ebx), %eax
3018 subl foo@gottpoff(%ebx), %eax
3019 addl foo@gotntpoff(%ebx), %eax
3020 movl foo@indntpoff, %eax
3021 movl \$foo@tpoff, %eax
3022 subl \$foo@tpoff, %eax
3023 leal foo@ntpoff(%ecx), %eax"
3027 .section ".tdata","awT",@progbits
3031 leaq foo@TLSGD(%rip), %rdi
3032 leaq foo@TLSLD(%rip), %rdi
3033 leaq foo@DTPOFF(%rax), %rdx
3034 movq foo@GOTTPOFF(%rip), %rax
3035 movq $foo@TPOFF, %rax'
3039 tls_as_opt=--fatal-warnings
3043 .section ".tdata","awT",@progbits
3046 addl r16 = @ltoff(@dtpmod(foo#)), gp
3047 addl r17 = @ltoff(@dtprel(foo#)), gp
3048 addl r18 = @ltoff(@tprel(foo#)), gp
3049 addl r19 = @dtprel(foo#), gp
3050 adds r21 = @dtprel(foo#), r13
3051 movl r23 = @dtprel(foo#)
3052 addl r20 = @tprel(foo#), gp
3053 adds r22 = @tprel(foo#), r13
3054 movl r24 = @tprel(foo#)'
3057 tls_as_opt=--fatal-warnings
3061 .section .tdata,"awT",@progbits
3065 addik r5,r20,x@TLSGD
3066 addik r5,r20,x@TLSLDM'
3069 tls_as_opt='--fatal-warnings'
3073 .section .tdata,"awT",@progbits
3077 addiu $4, $28, %tlsgd(x)
3078 addiu $4, $28, %tlsldm(x)
3079 lui $4, %dtprel_hi(x)
3080 addiu $4, $4, %dtprel_lo(x)
3081 lw $4, %gottprel(x)($28)
3082 lui $4, %tprel_hi(x)
3083 addiu $4, $4, %tprel_lo(x)'
3086 tls_as_opt='-32 --fatal-warnings'
3090 .section .tdata,"awT",@progbits
3095 move.l x@TLSGD(%a5),%a0
3096 move.l x@TLSLDM(%a5),%a0
3097 move.l x@TLSLDO(%a5),%a0
3098 move.l x@TLSIE(%a5),%a0
3099 move.l x@TLSLE(%a5),%a0'
3102 tls_as_opt='--fatal-warnings'
3106 .section ".tdata","awT",@progbits'
3109 tls_as_opt="--fatal-warnings"
3113 .section ".tdata","awT",%progbits
3117 add x0, x0, #:tlsgd_lo12:x
3122 tls_as_opt='--fatal-warnings'
3126 .extern __get_tpointer
3144 .section ".tdata","awT",@progbits
3152 addi 3,2,ld0@got@tlsgd
3158 addi 3,2,x1@got@tlsld
3164 addis 9,3,x2@dtprel@ha
3165 addi 9,9,x2@dtprel@l
3168 ld 9,x3@got@dtprel(2)
3174 tls_as_opt="-a64 --fatal-warnings"
3178 .section ".tdata","awT",@progbits
3186 addi 3,31,ld0@got@tlsgd
3188 addi 3,31,x1@got@tlsld
3191 addis 9,3,x2@dtprel@ha
3192 addi 9,9,x2@dtprel@l
3193 lwz 9,x3@got@tprel(31)
3196 addis 9,2,x2@tprel@ha
3197 addi 9,9,x2@tprel@l'
3200 tls_as_opt="-a32 --fatal-warnings"
3204 .section ".tdata","awT",@progbits
3213 l %r1,foo@GOTNTPOFF(%r12)
3214 l %r1,0(%r1):tls_load:foo
3215 bas %r14,0(%r1,%r13):tls_gdcall:foo
3216 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3219 tls_as_opt="-m31 --fatal-warnings"
3223 .section ".tdata","awT",@progbits
3231 lg %r1,foo@GOTNTPOFF(%r12)
3232 larl %r1,foo@INDNTPOFF
3233 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3234 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3237 tls_as_opt="-m64 -Aesame --fatal-warnings"
3239 sh-*-* | sh[34]-*-*)
3241 .section ".tdata","awT",@progbits
3251 tls_as_opt=--fatal-warnings
3255 sparc*-sun-solaris2.*)
3257 tga_func=__tls_get_addr
3263 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3265 .section ".tdata",#alloc,#write,#tls'
3270 .section ".tdata","awT",@progbits'
3273 tls_as_opt="-32 --fatal-warnings"
3275 conftest_s="$conftest_s
3278 sethi %tgd_hi22(foo), %o0
3279 add %o0, %tgd_lo10(foo), %o1
3280 add %l7, %o1, %o0, %tgd_add(foo)
3281 call __tls_get_addr, %tgd_call(foo)
3282 sethi %tldm_hi22(foo), %l1
3283 add %l1, %tldm_lo10(foo), %l2
3284 add %l7, %l2, %o0, %tldm_add(foo)
3285 call __tls_get_addr, %tldm_call(foo)
3286 sethi %tldo_hix22(foo), %l3
3287 xor %l3, %tldo_lox10(foo), %l4
3288 add %o0, %l4, %l5, %tldo_add(foo)
3289 sethi %tie_hi22(foo), %o3
3290 add %o3, %tie_lo10(foo), %o3
3291 ld [%l7 + %o3], %o2, %tie_ld(foo)
3292 add %g7, %o2, %o4, %tie_add(foo)
3293 sethi %tle_hix22(foo), %l1
3294 xor %l1, %tle_lox10(foo), %o5
3295 ld [%g7 + %o5], %o1"
3299 .section ".tdata","awT",@progbits
3302 addli r0, zero, tls_gd(foo)
3303 auli r0, zero, tls_gd_ha16(foo)
3304 addli r0, r0, tls_gd_lo16(foo)
3306 addli r0, zero, tls_ie(foo)
3307 auli r0, r0, tls_ie_ha16(foo)
3308 addli r0, r0, tls_ie_lo16(foo)'
3311 tls_as_opt="--fatal-warnings"
3315 .section ".tdata","awT",@progbits
3318 shl16insli r0, zero, hw0_last_tls_gd(foo)
3319 shl16insli r0, zero, hw1_last_tls_gd(foo)
3320 shl16insli r0, r0, hw0_tls_gd(foo)
3322 shl16insli r0, zero, hw1_last_tls_ie(foo)
3323 shl16insli r0, r0, hw0_tls_ie(foo)'
3326 tls_as_opt="--fatal-warnings"
3330 .section ".tdata","awT",@progbits
3333 movi a8, foo@TLSFUNC
3334 movi a10, foo@TLSARG
3335 callx8.tls a8, foo@TLSCALL'
3342 if test "x$enable_tls" = xno ; then
3343 : # TLS explicitly disabled.
3344 elif test "x$enable_tls" = xyes ; then
3345 set_have_as_tls=yes # TLS explicitly enabled.
3346 elif test -z "$tls_first_major"; then
3347 : # If we don't have a check, assume no support.
3349 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3350 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3351 [set_have_as_tls=yes])
3354 # TLS was introduced in the Solaris 9 FCS release. Support for GNU-style
3355 # TLS on x86 was only introduced in Solaris 9 4/04, replacing the earlier
3356 # Sun style that Sun ld and GCC don't support any longer.
3358 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3360 # Check ld and ld.so.1 TLS support.
3361 if echo "$ld_ver" | grep GNU > /dev/null; then
3362 # Assume all interesting versions of GNU ld have TLS support.
3363 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3367 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3369 min_tls_ld_vers_minor=374
3371 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3372 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3373 min_tls_ld_vers_minor=343
3376 if test "$ld_vers_major" -gt 1 || \
3377 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3383 AC_MSG_RESULT($ld_tls_support)
3386 save_LDFLAGS="$LDFLAGS"
3390 AC_MSG_CHECKING(library containing $tga_func)
3391 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3392 # (32-bit x86) only lived in libthread, so check for that. Keep
3393 # set_have_as_tls if found, disable if not.
3394 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3396 # Clear LIBS if we cannot support TLS.
3397 if test $set_have_as_tls = no; then
3400 # Always define LIB_TLS_SPEC, even without TLS support.
3401 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3402 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3403 AC_MSG_RESULT($LIBS)
3406 LDFLAGS="$save_LDFLAGS"
3409 if test $set_have_as_tls = yes ; then
3410 AC_DEFINE(HAVE_AS_TLS, 1,
3411 [Define if your assembler and linker support thread-local storage.])
3414 # Target-specific assembler checks.
3416 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3417 gcc_cv_ld_static_dynamic=no
3418 gcc_cv_ld_static_option='-Bstatic'
3419 gcc_cv_ld_dynamic_option='-Bdynamic'
3420 if test $in_tree_ld = yes ; then
3421 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
3422 gcc_cv_ld_static_dynamic=yes
3424 elif test x$gcc_cv_ld != x; then
3425 # Check if linker supports -Bstatic/-Bdynamic option
3426 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3427 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3428 gcc_cv_ld_static_dynamic=yes
3431 # AIX ld uses -b flags
3432 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3433 gcc_cv_ld_static_dynamic=yes
3434 gcc_cv_ld_static_option="-bstatic"
3435 gcc_cv_ld_dynamic_option="-bdynamic"
3437 # HP-UX ld uses -a flags to select between shared and archive.
3439 if test x"$gnu_ld" = xno; then
3440 gcc_cv_ld_static_dynamic=yes
3441 gcc_cv_ld_static_option="-aarchive_shared"
3442 gcc_cv_ld_dynamic_option="-adefault"
3445 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3447 gcc_cv_ld_static_dynamic=yes
3452 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3453 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3454 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3455 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3456 [Define to the linker option to disable use of shared objects.])
3457 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3458 [Define to the linker option to enable use of shared objects.])
3460 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3462 if test x"$demangler_in_ld" = xyes; then
3463 AC_MSG_CHECKING(linker --demangle support)
3464 gcc_cv_ld_demangle=no
3465 if test $in_tree_ld = yes; then
3466 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 \
3467 gcc_cv_ld_demangle=yes
3469 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3470 # Check if the GNU linker supports --demangle option
3471 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3472 gcc_cv_ld_demangle=yes
3475 if test x"$gcc_cv_ld_demangle" = xyes; then
3476 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3477 [Define if your linker supports --demangle option.])
3479 AC_MSG_RESULT($gcc_cv_ld_demangle)
3482 AC_MSG_CHECKING(linker plugin support)
3484 if test -f liblto_plugin.la; then
3485 save_ld_ver="$ld_ver"
3486 save_ld_vers_major="$ld_vers_major"
3487 save_ld_vers_minor="$ld_vers_minor"
3488 save_ld_is_gold="$ld_is_gold"
3492 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3494 # FIXME: ld_is_gold?
3495 ld_vers_major="$gcc_cv_gld_major_version"
3496 ld_vers_minor="$gcc_cv_gld_minor_version"
3498 # Determine plugin linker version.
3499 # FIXME: Partial duplicate from above, generalize.
3501 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3502 if echo "$ld_ver" | grep GNU > /dev/null; then
3503 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3505 ld_vers=`echo $ld_ver | sed -n \
3506 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3508 ld_vers=`echo $ld_ver | sed -n \
3509 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3511 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3512 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3517 # Determine plugin support.
3518 if echo "$ld_ver" | grep GNU > /dev/null; then
3519 # Require GNU ld or gold 2.21+ for plugin support by default.
3520 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3522 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3523 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3528 ld_ver="$save_ld_ver"
3529 ld_vers_major="$save_ld_vers_major"
3530 ld_vers_minor="$save_ld_vers_minor"
3531 ld_is_gold="$save_ld_is_gold"
3533 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3534 [Define to the level of your linker's plugin support.])
3535 AC_MSG_RESULT($gcc_cv_lto_plugin)
3539 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3540 [-mabi=lp64], [.text],,,)
3541 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3542 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3543 [Define if your assembler supports the -mabi option.])
3545 if test x$with_abi = xilp32; then
3546 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3547 Upgrade the Assembler.])
3549 if test x"$with_multilib_list" = xdefault; then
3550 TM_MULTILIB_CONFIG=lp64
3552 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3553 for aarch64_multilib in ${aarch64_multilibs}; do
3554 case ${aarch64_multilib} in
3556 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3557 Upgrade the Assembler.])
3565 # Enable default workaround for AArch64 Cortex-A53 erratum 835769.
3566 AC_ARG_ENABLE(fix-cortex-a53-835769,
3568 AS_HELP_STRING([--enable-fix-cortex-a53-835769],
3569 [enable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3570 AS_HELP_STRING([--disable-fix-cortex-a53-835769],
3571 [disable workaround for AArch64 Cortex-A53 erratum 835769 by default])
3576 tm_defines="${tm_defines} TARGET_FIX_ERR_A53_835769_DEFAULT=1"
3581 AC_MSG_ERROR(['$enableval' is an invalid value for --enable-fix-cortex-a53-835769.\
3582 Valid choices are 'yes' and 'no'.])
3590 # All TARGET_ABI_OSF targets.
3591 alpha*-*-linux* | alpha*-*-*bsd*)
3592 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3593 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3596 extbl $3, $2, $3 !lituse_bytoff!1
3597 ldq $2, a($29) !literal!1
3598 ldq $4, b($29) !literal!2
3599 ldq_u $3, 0($2) !lituse_base!1
3600 ldq $27, f($29) !literal!5
3601 jsr $26, ($27), f !lituse_jsr!5
3602 ldah $29, 0($26) !gpdisp!3
3603 lda $0, c($29) !gprel
3604 ldah $1, d($29) !gprelhigh
3605 lda $1, d($1) !gprellow
3606 lda $29, 0($29) !gpdisp!3],,
3607 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3608 [Define if your assembler supports explicit relocations.])])
3609 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3610 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3613 ldq $27, a($29) !literal!1
3614 jsr $26, ($27), a !lituse_jsrdirect!1],,
3615 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3616 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3620 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3621 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3622 [-no-mul-bug-abort], [.text],,
3623 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3624 [Define if your assembler supports the -no-mul-bug-abort option.])])
3628 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3629 [.register %g2, #scratch],,
3630 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3631 [Define if your assembler supports .register.])])
3633 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3634 [.section "nobits",#alloc,#write,#nobits
3635 .section "progbits",#alloc,#write,#progbits])
3636 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3637 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3638 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3640 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3642 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3643 [Define if your assembler supports -relax option.])])
3645 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3646 gcc_cv_as_sparc_gotdata_op,,
3653 sethi %gdop_hix22(foo), %g1
3654 xor %g1, %gdop_lox10(foo), %g1
3655 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3656 [if test x$gcc_cv_ld != x \
3657 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3658 if test x$gcc_cv_objdump != x; then
3659 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3660 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3661 gcc_cv_as_sparc_gotdata_op=no
3663 gcc_cv_as_sparc_gotdata_op=yes
3668 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3669 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3671 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3672 gcc_cv_as_sparc_ua_pcrel,,
3680 .uaword %r_disp32(foo)],
3681 [if test x$gcc_cv_ld != x \
3682 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3683 gcc_cv_as_sparc_ua_pcrel=yes
3686 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3687 [Define if your assembler and linker support unaligned PC relative relocs.])
3689 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3690 gcc_cv_as_sparc_ua_pcrel_hidden,,
3695 .uaword %r_disp32(foo)
3696 .byte 0x32, 0x33, 0x34
3701 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3702 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3703 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3704 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3705 if $gcc_cv_objdump -R conftest 2> /dev/null \
3706 | grep 'DISP32' > /dev/null 2>&1; then
3709 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3713 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3714 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3715 ]) # unaligned pcrel relocs
3717 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3718 gcc_cv_as_sparc_offsetable_lo10,,
3721 or %g1, %lo(ab) + 12, %g1
3722 or %g1, %lo(ab + 12), %g1],
3723 [if test x$gcc_cv_objdump != x \
3724 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3725 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3726 gcc_cv_as_sparc_offsetable_lo10=yes
3728 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3729 [Define if your assembler supports offsetable %lo().])])
3731 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3732 gcc_cv_as_sparc_fmaf,,
3735 .register %g2, #scratch
3736 .register %g3, #scratch
3738 fmaddd %f0, %f2, %f4, %f6
3739 addxccc %g1, %g2, %g3
3740 fsrl32 %f2, %f4, %f8
3741 fnaddd %f10, %f12, %f14],,
3742 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3743 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3745 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3746 gcc_cv_as_sparc_sparc4,,
3749 .register %g2, #scratch
3750 .register %g3, #scratch
3753 1: cwbneg %g2, %g3, 1f
3756 aes_kexpand0 %f4, %f6, %f8
3757 des_round %f38, %f40, %f42, %f44
3758 camellia_f %f54, %f56, %f58, %f60
3759 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3760 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3761 [Define if your assembler supports SPARC4 instructions.])])
3763 gcc_GAS_CHECK_FEATURE([LEON instructions],
3764 gcc_cv_as_sparc_leon,,
3767 .register %g2, #scratch
3768 .register %g3, #scratch
3772 casa [[%g2]] 0xb, %g3, %g1],,
3773 [AC_DEFINE(HAVE_AS_LEON, 1,
3774 [Define if your assembler supports LEON instructions.])])
3778 i[34567]86-*-* | x86_64-*-*)
3782 # Full C++ conformance when using a shared libstdc++-v3 requires some
3783 # support from the Cygwin DLL, which in more recent versions exports
3784 # wrappers to aid in interposing and redirecting operators new, delete,
3785 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3786 # are configuring for a version of Cygwin that exports the wrappers.
3787 if test x$host = x$target && test x$host_cpu = xi686; then
3788 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3790 # Can't check presence of libc functions during cross-compile, so
3791 # we just have to assume we're building for an up-to-date target.
3792 gcc_ac_cygwin_dll_wrappers=yes
3794 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3795 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3796 [Define if you want to generate code by default that assumes that the
3797 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3800 cygwin* | pe | mingw32* | interix*)
3801 # Recent binutils allows the three-operand form of ".comm" on PE. This
3802 # definition is used unconditionally to initialise the default state of
3803 # the target option variable that governs usage of the feature.
3804 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3805 [2,19,52],,[.comm foo,1,32])
3806 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3807 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3808 [Define if your assembler supports specifying the alignment
3809 of objects allocated using the GAS .comm command.])
3810 # Used for DWARF 2 in PE
3811 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3812 gcc_cv_as_ix86_pe_secrel32,
3818 [if test x$gcc_cv_ld != x \
3819 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3820 gcc_cv_as_ix86_pe_secrel32=yes
3823 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3824 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3825 # Test if the assembler supports the extended form of the .section
3826 # directive that specifies section alignment. LTO support uses this,
3827 # but normally only after installation, so we warn but don't fail the
3828 # configure if LTO is enabled but the assembler does not support it.
3829 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3830 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3831 if test x$gcc_cv_as_section_has_align != xyes; then
3832 case ",$enable_languages," in
3834 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3838 # Test if the assembler supports the section flag 'e' for specifying
3839 # an excluded section.
3840 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3844 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3845 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3846 [Define if your assembler supports specifying the section flag e.])
3850 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3851 gcc_cv_as_ix86_filds,,,
3852 [filds mem; fists mem],,
3853 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3854 [Define if your assembler uses filds and fists mnemonics.])])
3856 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3857 gcc_cv_as_ix86_fildq,,,
3858 [fildq mem; fistpq mem],,
3859 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3860 [Define if your assembler uses fildq and fistq mnemonics.])])
3862 gcc_GAS_CHECK_FEATURE([cmov syntax],
3863 gcc_cv_as_ix86_cmov_sun_syntax,,,
3864 [cmovl.l %edx, %eax],,
3865 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3866 [Define if your assembler supports the Sun syntax for cmov.])])
3868 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3869 gcc_cv_as_ix86_ffreep,,,
3871 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3872 [Define if your assembler supports the ffreep mnemonic.])])
3874 gcc_GAS_CHECK_FEATURE([.quad directive],
3875 gcc_cv_as_ix86_quad,,,
3877 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3878 [Define if your assembler supports the .quad directive.])])
3880 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3881 gcc_cv_as_ix86_sahf,,,
3884 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3885 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3887 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3888 gcc_cv_as_ix86_interunit_movq,,,
3892 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3893 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3894 [Define if your assembler supports interunit movq mnemonic.])
3896 gcc_GAS_CHECK_FEATURE([hle prefixes],
3897 gcc_cv_as_ix86_hle,,,
3898 [lock xacquire cmpxchg %esi, (%ecx)],,
3899 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3900 [Define if your assembler supports HLE prefixes.])])
3902 gcc_GAS_CHECK_FEATURE([swap suffix],
3903 gcc_cv_as_ix86_swap,,,
3904 [movl.s %esp, %ebp],,
3905 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3906 [Define if your assembler supports the swap suffix.])])
3908 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3909 gcc_cv_as_ix86_diff_sect_delta,,,
3917 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
3918 [Define if your assembler supports the subtraction of symbols in different sections.])])
3920 # These two are used unconditionally by i386.[ch]; it is to be defined
3921 # to 1 if the feature is present, 0 otherwise.
3922 as_ix86_gotoff_in_data_opt=
3923 if test x$gas = xyes; then
3924 as_ix86_gotoff_in_data_opt="--32"
3926 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
3927 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
3928 [$as_ix86_gotoff_in_data_opt],
3934 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
3935 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
3936 [Define true if the assembler supports '.long foo@GOTOFF'.])
3938 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
3939 gcc_cv_as_ix86_rep_lock_prefix,,,
3945 lock addl %edi, (%eax,%esi)
3946 lock orl $0, (%esp)],,
3947 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
3948 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
3950 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
3951 gcc_cv_as_ix86_ud2,,,
3953 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
3954 [Define if your assembler supports the 'ud2' mnemonic.])])
3956 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
3957 gcc_cv_as_ix86_tlsgdplt,,,
3958 [call tls_gd@tlsgdplt],
3959 [if test x$gcc_cv_ld != x \
3960 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3961 gcc_cv_as_ix86_tlsgdplt=yes
3964 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
3965 [Define if your assembler and linker support @tlsgdplt.])])
3968 .section .tdata,"aw'$tls_section_flag'",@progbits
3970 .section .text,"ax",@progbits
3971 call tls_ld@tlsldmplt'
3972 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
3973 gcc_cv_as_ix86_tlsldmplt,,,
3975 [if test x$gcc_cv_ld != x \
3976 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3977 gcc_cv_as_ix86_tlsldmplt=yes
3980 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
3981 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
3982 [Define to 1 if your assembler and linker support @tlsldmplt.])
3984 # Enforce 32-bit output with gas and gld.
3985 if test x$gas = xyes; then
3986 as_ix86_tls_ldm_opt="--32"
3988 if echo "$ld_ver" | grep GNU > /dev/null; then
3989 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
3990 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
3992 ld_ix86_tls_ldm_opt="-melf_i386"
3996 .section .text,"ax",@progbits
3998 .type _start, @function
4000 leal value@tlsldm(%ebx), %eax
4001 call ___tls_get_addr@plt
4003 .section .tdata,"aw'$tls_section_flag'",@progbits
4004 .type value, @object
4006 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4007 gcc_cv_as_ix86_tlsldm,,
4008 [$as_ix86_tls_ldm_opt],
4010 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4011 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4012 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4013 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4014 gcc_cv_as_ix86_tlsldm=yes
4018 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4019 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4020 [Define to 1 if your assembler and linker support @tlsldm.])
4025 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4026 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4028 addl r15 = @ltoffx(x#), gp
4030 ld8.mov r16 = [[r15]], x#],,
4031 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4032 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4038 *-*-aix*) conftest_s=' .machine "pwr5"
4042 gcc_GAS_CHECK_FEATURE([.machine directive support],
4043 gcc_cv_as_machine_directive,,,
4044 [ .machine ppc7400])
4045 if test x$gcc_cv_as_machine_directive != xyes; then
4046 echo "*** This target requires an assembler supporting \".machine\"" >&2
4047 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4048 test x$build = x$target && exit 1
4052 *) conftest_s=' .machine power4
4057 gcc_GAS_CHECK_FEATURE([mfcr field support],
4058 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4060 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4061 [Define if your assembler supports mfcr field.])])
4064 *-*-aix*) conftest_s=' .machine "pwr5"
4067 *) conftest_s=' .machine power5
4072 gcc_GAS_CHECK_FEATURE([popcntb support],
4073 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4075 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4076 [Define if your assembler supports popcntb field.])])
4079 *-*-aix*) conftest_s=' .machine "pwr5x"
4082 *) conftest_s=' .machine power5
4087 gcc_GAS_CHECK_FEATURE([fp round support],
4088 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4090 [AC_DEFINE(HAVE_AS_FPRND, 1,
4091 [Define if your assembler supports fprnd.])])
4094 *-*-aix*) conftest_s=' .machine "pwr6"
4097 *) conftest_s=' .machine power6
4102 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4103 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4105 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4106 [Define if your assembler supports mffgpr and mftgpr.])])
4109 *-*-aix*) conftest_s=' .csect .text[[PR]]
4111 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4115 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4116 *) conftest_s=' .text
4118 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4121 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4122 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4124 [AC_DEFINE(HAVE_AS_REL16, 1,
4125 [Define if your assembler supports R_PPC_REL16 relocs.])])
4128 *-*-aix*) conftest_s=' .machine "pwr6"
4131 *) conftest_s=' .machine power6
4136 gcc_GAS_CHECK_FEATURE([compare bytes support],
4137 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4139 [AC_DEFINE(HAVE_AS_CMPB, 1,
4140 [Define if your assembler supports cmpb.])])
4143 *-*-aix*) conftest_s=' .machine "pwr6"
4146 *) conftest_s=' .machine power6
4151 gcc_GAS_CHECK_FEATURE([decimal float support],
4152 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4154 [AC_DEFINE(HAVE_AS_DFP, 1,
4155 [Define if your assembler supports DFP instructions.])])
4158 *-*-aix*) conftest_s=' .machine "pwr7"
4161 *) conftest_s=' .machine power7
4166 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4167 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4169 [AC_DEFINE(HAVE_AS_VSX, 1,
4170 [Define if your assembler supports VSX instructions.])])
4173 *-*-aix*) conftest_s=' .machine "pwr7"
4176 *) conftest_s=' .machine power7
4181 gcc_GAS_CHECK_FEATURE([popcntd support],
4182 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4184 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4185 [Define if your assembler supports POPCNTD instructions.])])
4188 *-*-aix*) conftest_s=' .machine "pwr8"
4189 .csect .text[[PR]]';;
4190 *) conftest_s=' .machine power8
4194 gcc_GAS_CHECK_FEATURE([power8 support],
4195 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4197 [AC_DEFINE(HAVE_AS_POWER8, 1,
4198 [Define if your assembler supports POWER8 instructions.])])
4201 *-*-aix*) conftest_s=' .csect .text[[PR]]
4203 *) conftest_s=' .text
4207 gcc_GAS_CHECK_FEATURE([lwsync support],
4208 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4210 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4211 [Define if your assembler supports LWSYNC instructions.])])
4214 *-*-aix*) conftest_s=' .machine "476"
4217 *) conftest_s=' .machine "476"
4222 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4223 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4225 [AC_DEFINE(HAVE_AS_DCI, 1,
4226 [Define if your assembler supports the DCI/ICI instructions.])])
4228 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4229 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4230 [.gnu_attribute 4,1],,
4231 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4232 [Define if your assembler supports .gnu_attribute.])])
4234 gcc_GAS_CHECK_FEATURE([tls marker support],
4235 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4236 [ bl __tls_get_addr(x@tlsgd)],,
4237 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4238 [Define if your assembler supports arg info for __tls_get_addr.])])
4242 gcc_GAS_CHECK_FEATURE([.ref support],
4243 gcc_cv_as_aix_ref, [2,21,0],,
4244 [ .csect stuff[[rw]]
4250 [AC_DEFINE(HAVE_AS_REF, 1,
4251 [Define if your assembler supports .ref])])
4257 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4258 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4259 [ lw $4,%gp_rel(foo)($4)],,
4260 [if test x$target_cpu_default = x
4261 then target_cpu_default=MASK_EXPLICIT_RELOCS
4262 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4264 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4265 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4266 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4267 [Define if the assembler understands -mno-shared.])])
4269 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4270 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4271 [.gnu_attribute 4,1],,
4272 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4273 [Define if your assembler supports .gnu_attribute.])])
4275 gcc_GAS_CHECK_FEATURE([.micromips support],
4276 gcc_cv_as_micromips_support,,[--fatal-warnings],
4278 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4279 [Define if your assembler supports the .set micromips directive])])
4281 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4282 gcc_cv_as_mips_dtprelword, [2,18,0],,
4283 [.section .tdata,"awT",@progbits
4287 .dtprelword x+0x8000],,
4288 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4289 [Define if your assembler supports .dtprelword.])])
4291 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4292 gcc_cv_as_mips_dspr1_mult,,,
4302 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4303 [Define if your assembler supports DSPR1 mult.])])
4305 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4306 gcc_cv_as_ld_jalr_reloc=no
4307 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4308 if test $in_tree_ld = yes ; then
4309 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 \
4310 && test $in_tree_ld_is_elf = yes; then
4311 gcc_cv_as_ld_jalr_reloc=yes
4313 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4314 echo ' .ent x' > conftest.s
4315 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
4316 echo ' ld $25,%call16(y)($28)' >> conftest.s
4317 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4318 echo '1: jalr $25' >> conftest.s
4319 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4320 echo '1: jalr $25' >> conftest.s
4321 echo ' .end x' >> conftest.s
4322 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4323 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4324 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4325 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4326 gcc_cv_as_ld_jalr_reloc=yes
4332 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4333 if test x$target_cpu_default = x; then
4334 target_cpu_default=MASK_RELAX_PIC_CALLS
4336 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4339 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4341 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4342 [gcc_cv_ld_mips_personality_relaxation],
4343 [gcc_cv_ld_mips_personality_relaxation=no
4344 if test $in_tree_ld = yes ; then
4345 if test "$gcc_cv_gld_major_version" -eq 2 \
4346 -a "$gcc_cv_gld_minor_version" -ge 21 \
4347 -o "$gcc_cv_gld_major_version" -gt 2; then
4348 gcc_cv_ld_mips_personality_relaxation=yes
4350 elif test x$gcc_cv_as != x \
4351 -a x$gcc_cv_ld != x \
4352 -a x$gcc_cv_readelf != x ; then
4353 cat > conftest.s <<EOF
4355 .cfi_personality 0x80,indirect_ptr
4362 .section .data,"aw",@progbits
4366 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4367 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4368 if $gcc_cv_readelf -d conftest 2>&1 \
4369 | grep TEXTREL > /dev/null 2>&1; then
4371 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4372 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4375 gcc_cv_ld_mips_personality_relaxation=yes
4379 rm -f conftest.s conftest.o conftest])
4380 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4381 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4382 [Define if your linker can relax absolute .eh_frame personality
4383 pointers into PC-relative form.])
4386 gcc_GAS_CHECK_FEATURE([-mnan= support],
4387 gcc_cv_as_mips_nan,,
4389 [AC_DEFINE(HAVE_AS_NAN, 1,
4390 [Define if the assembler understands -mnan=.])])
4391 if test x$gcc_cv_as_mips_nan = xno \
4392 && test x$with_nan != x; then
4394 [Requesting --with-nan= requires assembler support for -mnan=])
4399 # Mips and HP-UX need the GNU assembler.
4400 # Linux on IA64 might be able to use the Intel assembler.
4403 mips*-*-* | *-*-hpux* )
4404 if test x$gas_flag = xyes \
4405 || test x"$host" != x"$build" \
4406 || test ! -x "$gcc_cv_as" \
4407 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4410 echo "*** This configuration requires the GNU assembler" >&2
4416 # ??? Not all targets support dwarf2 debug_line, even within a version
4417 # of gas. Moreover, we need to emit a valid instruction to trigger any
4418 # info to the output file. So, as supported targets are added to gas 2.11,
4419 # add some instruction here to (also) show we expect this might work.
4420 # ??? Once 2.11 is released, probably need to add first known working
4421 # version to the per-target configury.
4423 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4424 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4425 | xstormy16 | xtensa)
4435 if test x"$insn" != x; then
4437 .file 1 \"conftest.s\"
4440 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4441 gcc_cv_as_dwarf2_debug_line,
4442 [elf,2,11,0],, [$conftest_s],
4443 [if test x$gcc_cv_objdump != x \
4444 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4445 | grep debug_line > /dev/null 2>&1; then
4446 gcc_cv_as_dwarf2_debug_line=yes
4449 # The .debug_line file table must be in the exact order that
4450 # we specified the files, since these indices are also used
4451 # by DW_AT_decl_file. Approximate this test by testing if
4452 # the assembler bitches if the same index is assigned twice.
4453 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4454 gcc_cv_as_dwarf2_file_buggy,,,
4458 if test $gcc_cv_as_dwarf2_debug_line = yes \
4459 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4460 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4461 [Define if your assembler supports dwarf2 .file/.loc directives,
4462 and preserves file table indices exactly as given.])
4465 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4466 gcc_cv_as_gdwarf2_flag,
4467 [elf,2,11,0], [--gdwarf2], [$insn],,
4468 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4469 [Define if your assembler supports the --gdwarf2 option.])])
4471 gcc_GAS_CHECK_FEATURE([--gstabs option],
4472 gcc_cv_as_gstabs_flag,
4473 [elf,2,11,0], [--gstabs], [$insn],
4474 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4475 # and warns about it, but still exits successfully. So check for
4477 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4479 else gcc_cv_as_gstabs_flag=yes
4481 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4482 [Define if your assembler supports the --gstabs option.])])
4484 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4485 gcc_cv_as_debug_prefix_map_flag,
4486 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4487 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4488 [Define if your assembler supports the --debug-prefix-map option.])])
4491 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4494 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4495 [Define if your assembler supports .lcomm with an alignment field.])])
4497 if test x$with_sysroot = x && test x$host = x$target \
4498 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4499 && test "$prefix" != "NONE"; then
4500 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4501 [Define to PREFIX/include if cpp should also search that directory.])
4504 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4505 if test "x$with_headers" != x; then
4506 target_header_dir=$with_headers
4507 elif test "x$with_sysroot" = x; then
4508 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4509 elif test "x$with_build_sysroot" != "x"; then
4510 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4511 elif test "x$with_sysroot" = xyes; then
4512 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4514 target_header_dir="${with_sysroot}${native_system_header_dir}"
4517 target_header_dir=${native_system_header_dir}
4520 # Determine the version of glibc, if any, used on the target.
4521 AC_MSG_CHECKING([for target glibc version])
4522 AC_ARG_WITH([glibc-version],
4523 [AS_HELP_STRING([--with-glibc-version=M.N],
4524 [assume GCC used with glibc version M.N or later])], [
4525 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4526 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4527 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4529 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4531 glibc_version_major=0
4532 glibc_version_minor=0
4533 [if test -f $target_header_dir/features.h \
4534 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4535 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4536 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4537 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4539 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4541 AC_ARG_ENABLE(gnu-unique-object,
4542 [AS_HELP_STRING([--enable-gnu-unique-object],
4543 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4544 [case $enable_gnu_unique_object in
4546 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4547 Valid choices are 'yes' and 'no'.]) ;;
4549 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4551 [.type foo, '$target_type_format_char'gnu_unique_object],,
4552 # We need to unquote above to to use the definition from config.gcc.
4553 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4554 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4556 if test x$enable_gnu_unique_object = xyes; then
4557 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4558 [Define if your assembler supports @gnu_unique_object.])
4561 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4562 [gcc_cv_as_line_zero],
4563 [gcc_cv_as_line_zero=no
4564 if test $in_tree_gas = yes; then
4565 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4566 elif test "x$gcc_cv_as" != x; then
4567 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4568 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4569 test "x`cat conftest.out`" = x
4571 gcc_cv_as_line_zero=yes
4573 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4574 cat conftest.s >&AS_MESSAGE_LOG_FD
4575 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4576 cat conftest.out >&AS_MESSAGE_LOG_FD
4578 rm -f conftest.o conftest.s conftest.out
4580 if test "x$gcc_cv_as_line_zero" = xyes; then
4581 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4582 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4585 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4586 gcc_cv_ld_eh_frame_hdr=no
4587 if test $in_tree_ld = yes ; then
4588 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 \
4589 && test $in_tree_ld_is_elf = yes; then
4590 gcc_cv_ld_eh_frame_hdr=yes
4592 elif test x$gcc_cv_ld != x; then
4593 if echo "$ld_ver" | grep GNU > /dev/null; then
4594 # Check if linker supports --eh-frame-hdr option
4595 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4596 gcc_cv_ld_eh_frame_hdr=yes
4601 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4602 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4603 gcc_cv_ld_eh_frame_hdr=yes
4609 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4610 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4611 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4612 [Define if your linker supports .eh_frame_hdr.])
4613 AC_ARG_ENABLE(eh-frame-hdr-for-static,
4614 [AS_HELP_STRING([--enable-eh-frame-hdr-for-static],
4615 [enable linker PT_GNU_EH_FRAME support for static executable])],
4616 [case $enable_eh_frame_hdr_for_static in
4618 *) AC_MSG_ERROR(['$enable_eh_frame_hdr_for_static' is an invalid
4619 value for --enable-eh-frame-hdr-for-static.
4620 Valid choices are 'yes' and 'no'.]) ;;
4622 ## Only support for glibc 2.3.0 or higher with AT_PHDR/AT_PHNUM from
4624 # [[if test x$host = x$build -a x$host = x$target &&
4625 # ldd --version 2>&1 >/dev/null &&
4626 # glibcver=`ldd --version 2>/dev/null | sed 's/.* //;q'`; then
4627 # glibcmajor=`expr "$glibcver" : "\([0-9]*\)"`
4628 # glibcminor=`expr "$glibcver" : "[2-9]*\.\([0-9]*\)"`
4629 # glibcnum=`expr $glibcmajor \* 1000 + $glibcminor`
4630 # if test "$glibcnum" -ge 2003 ; then
4631 # auvx=`LD_SHOW_AUXV=1 ldd 2>/dev/null`
4632 # if echo "$auvx" | grep AT_PHDR > /dev/null &&
4633 # echo "$auvx" | grep AT_PHNUM > /dev/null; then
4634 # enable_eh_frame_hdr_for_static=yes
4639 if test x$enable_eh_frame_hdr_for_static = xyes; then
4640 AC_DEFINE(USE_EH_FRAME_HDR_FOR_STATIC, 1,
4641 [Define if your system supports PT_GNU_EH_FRAME for static executable.])
4644 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4646 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4647 gcc_cv_ld_eh_frame_ciev3=no
4648 if test $in_tree_ld = yes ; then
4649 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 \
4650 && test $in_tree_ld_is_elf = yes; then
4651 gcc_cv_ld_eh_frame_ciev3=yes
4653 elif test x$gcc_cv_ld != x; then
4654 if echo "$ld_ver" | grep GNU > /dev/null; then
4655 gcc_cv_ld_eh_frame_ciev3=yes
4656 if test 0"$ld_date" -lt 20040513; then
4657 if test -n "$ld_date"; then
4658 # If there was date string, but was earlier than 2004-05-13, fail
4659 gcc_cv_ld_eh_frame_ciev3=no
4660 elif test "$ld_vers_major" -lt 2; then
4661 gcc_cv_ld_eh_frame_ciev3=no
4662 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4663 gcc_cv_ld_eh_frame_ciev3=no
4669 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4670 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4671 gcc_cv_ld_eh_frame_ciev3=yes
4677 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4678 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4679 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4680 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4682 AC_MSG_CHECKING(linker position independent executable support)
4684 if test $in_tree_ld = yes ; then
4685 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 \
4686 && test $in_tree_ld_is_elf = yes; then
4689 elif test x$gcc_cv_ld != x; then
4690 # Check if linker supports -pie option
4691 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4695 if test x"$gcc_cv_ld_pie" = xyes; then
4696 AC_DEFINE(HAVE_LD_PIE, 1,
4697 [Define if your linker supports -pie option.])
4699 AC_MSG_RESULT($gcc_cv_ld_pie)
4701 AC_MSG_CHECKING(linker PIE support with copy reloc)
4702 gcc_cv_ld_pie_copyreloc=no
4703 if test $gcc_cv_ld_pie = yes ; then
4704 if test $in_tree_ld = yes ; then
4705 if test "$gcc_cv_gld_major_version" -eq 2 -a "$gcc_cv_gld_minor_version" -ge 25 -o "$gcc_cv_gld_major_version" -gt 2; then
4706 gcc_cv_ld_pie_copyreloc=yes
4708 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4709 # Check if linker supports -pie option with copy reloc
4711 i?86-*-linux* | x86_64-*-linux*)
4712 cat > conftest1.s <<EOF
4715 .type a_glob, @object
4720 cat > conftest2.s <<EOF
4723 .type main, @function
4725 movl %eax, a_glob(%rip)
4728 if $gcc_cv_as --64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4729 && $gcc_cv_ld -shared -melf_x86_64 -o conftest1.so conftest1.o > /dev/null 2>&1 \
4730 && $gcc_cv_as --64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4731 && $gcc_cv_ld -pie -melf_x86_64 -o conftest conftest2.o conftest1.so > /dev/null 2>&1; then
4732 gcc_cv_ld_pie_copyreloc=yes
4734 rm -f conftest conftest1.so conftest1.o conftest2.o conftest1.s conftest2.s
4739 AC_DEFINE_UNQUOTED(HAVE_LD_PIE_COPYRELOC,
4740 [`if test x"$gcc_cv_ld_pie_copyreloc" = xyes; then echo 1; else echo 0; fi`],
4741 [Define 0/1 if your linker supports -pie option with copy reloc.])
4742 AC_MSG_RESULT($gcc_cv_ld_pie_copyreloc)
4744 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4745 gcc_cv_ld_eh_gc_sections=no
4746 if test $in_tree_ld = yes ; then
4747 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 \
4748 && test $in_tree_ld_is_elf = yes; then
4749 gcc_cv_ld_eh_gc_sections=yes
4751 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4752 cat > conftest.s <<EOF
4755 .type _start, @function
4758 .size _start, .-_start
4759 .section .text.foo,"ax",@progbits
4760 .type foo, @function
4764 .section .gcc_except_table.foo,"a",@progbits
4767 .section .eh_frame,"a",@progbits
4770 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4771 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4772 | grep "gc-sections option ignored" > /dev/null; then
4773 gcc_cv_ld_eh_gc_sections=no
4774 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4775 | grep gcc_except_table > /dev/null; then
4776 gcc_cv_ld_eh_gc_sections=yes
4777 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4778 if test x$gcc_cv_as_comdat_group != xyes; then
4779 gcc_cv_ld_eh_gc_sections=no
4780 cat > conftest.s <<EOF
4783 .type _start, @function
4786 .size _start, .-_start
4787 .section .gnu.linkonce.t.foo,"ax",@progbits
4788 .type foo, @function
4792 .section .gcc_except_table.foo,"a",@progbits
4795 .section .eh_frame,"a",@progbits
4798 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4799 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4800 | grep "gc-sections option ignored" > /dev/null; then
4801 gcc_cv_ld_eh_gc_sections=no
4802 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4803 | grep gcc_except_table > /dev/null; then
4804 gcc_cv_ld_eh_gc_sections=yes
4810 rm -f conftest.s conftest.o conftest
4814 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4815 gcc_cv_ld_eh_gc_sections=no
4818 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4819 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4820 [Define if your linker supports garbage collection of
4821 sections in presence of EH frames.])
4823 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4825 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4826 gcc_cv_ld_eh_gc_sections_bug=no
4827 if test $in_tree_ld = yes ; then
4828 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 \
4829 && test $in_tree_ld_is_elf = yes; then
4830 gcc_cv_ld_eh_gc_sections_bug=yes
4832 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
4833 gcc_cv_ld_eh_gc_sections_bug=yes
4834 cat > conftest.s <<EOF
4837 .type _start, @function
4840 .size _start, .-_start
4841 .section .text.startup.foo,"ax",@progbits
4842 .type foo, @function
4846 .section .gcc_except_table.foo,"a",@progbits
4849 .section .eh_frame,"a",@progbits
4852 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4853 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4854 | grep "gc-sections option ignored" > /dev/null; then
4856 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4857 | grep gcc_except_table > /dev/null; then
4858 gcc_cv_ld_eh_gc_sections_bug=no
4861 rm -f conftest.s conftest.o conftest
4863 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4864 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4865 [Define if your linker has buggy garbage collection of
4866 sections support when .text.startup.foo like sections are used.])
4868 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4874 AC_CACHE_CHECK(linker --as-needed support,
4875 gcc_cv_ld_as_needed,
4876 [gcc_cv_ld_as_needed=no
4877 gcc_cv_ld_as_needed_option='--as-needed'
4878 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4879 if test $in_tree_ld = yes ; then
4880 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 \
4881 && test $in_tree_ld_is_elf = yes; then
4882 gcc_cv_ld_as_needed=yes
4884 elif test x$gcc_cv_ld != x; then
4885 # Check if linker supports --as-needed and --no-as-needed options
4886 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4887 gcc_cv_ld_as_needed=yes
4890 # Solaris 2 ld always supports -z ignore/-z record.
4892 gcc_cv_ld_as_needed=yes
4893 gcc_cv_ld_as_needed_option="-z ignore"
4894 gcc_cv_ld_no_as_needed_option="-z record"
4899 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4900 # dl_iterate_phdr, i.e. since Solaris 11.
4902 *-*-solaris2.1[[1-9]]*)
4904 i?86-*-* | x86_64-*-*)
4905 if echo "$ld_ver" | grep GNU > /dev/null; then
4906 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4907 gcc_cv_ld_as_needed=no
4913 gcc_cv_ld_as_needed=no
4917 if test x"$gcc_cv_ld_as_needed" = xyes; then
4918 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4919 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4920 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4921 [Define to the linker option to ignore unused dependencies.])
4922 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4923 [Define to the linker option to keep unused dependencies.])
4926 AC_MSG_CHECKING(linker mapfile support for clearing hardware capabilities)
4927 saved_LDFLAGS="$LDFLAGS"
4928 for clearcap_map in sol2-clearcapv2.map sol2-clearcap.map; do
4929 LDFLAGS="$saved_LDFLAGS -Wl,-M,${srcdir}/config/$clearcap_map"
4930 AC_LINK_IFELSE([int main(void) {return 0;}],
4931 [gcc_cv_ld_clearcap=yes; break], [gcc_cv_ld_clearcap=no])
4933 LDFLAGS="$saved_LDFLAGS"
4934 if test "x$gcc_cv_ld_clearcap" = xyes; then
4935 AC_DEFINE([HAVE_LD_CLEARCAP], 1,
4936 [Define if the linker supports clearing hardware capabilities via mapfile.])
4937 AC_CONFIG_LINKS([clearcap.map:${srcdir}/config/$clearcap_map])
4939 AC_MSG_RESULT($gcc_cv_ld_clearcap)
4941 case "$target:$tm_file" in
4942 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4945 emul_name="-melf64lppc"
4948 emul_name="-melf64ppc"
4951 emul_name="-melf64ppc_fbsd"
4954 AC_CACHE_CHECK(linker support for omitting dot symbols,
4955 gcc_cv_ld_no_dot_syms,
4956 [gcc_cv_ld_no_dot_syms=no
4957 if test x"$ld_is_gold" = xyes; then
4958 gcc_cv_ld_no_dot_syms=yes
4959 elif test $in_tree_ld = yes ; then
4960 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
4961 gcc_cv_ld_no_dot_syms=yes
4963 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4964 cat > conftest1.s <<EOF
4968 cat > conftest2.s <<EOF
4969 .section ".opd","aw"
4974 .quad .LEfoo,.TOC.@tocbase,0
4980 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4981 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4982 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4983 gcc_cv_ld_no_dot_syms=yes
4985 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4988 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4989 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4990 [Define if your PowerPC64 linker only needs function descriptor syms.])
4993 AC_CACHE_CHECK(linker large toc support,
4994 gcc_cv_ld_large_toc,
4995 [gcc_cv_ld_large_toc=no
4996 if test x"$ld_is_gold" = xyes; then
4997 gcc_cv_ld_large_toc=yes
4998 elif test $in_tree_ld = yes ; then
4999 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
5000 gcc_cv_ld_large_toc=yes
5002 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5003 cat > conftest.s <<EOF
5004 .section ".tbss","awT",@nobits
5010 addis 9,13,ie0@got@tprel@ha
5011 ld 9,ie0@got@tprel@l(9)
5013 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5014 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5015 gcc_cv_ld_large_toc=yes
5017 rm -f conftest conftest.o conftest.s
5020 if test x"$gcc_cv_ld_large_toc" = xyes; then
5021 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5022 [Define if your PowerPC64 linker supports a large TOC.])
5029 AC_CACHE_CHECK(linker large toc support,
5030 gcc_cv_ld_large_toc,
5031 [gcc_cv_ld_large_toc=no
5032 if test x$gcc_cv_as != x ; then
5033 cat > conftest.s <<EOF
5043 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5044 gcc_cv_ld_large_toc=yes
5046 rm -f conftest conftest.o conftest.s
5049 if test x"$gcc_cv_ld_large_toc" = xyes; then
5050 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5051 [Define if your PowerPC64 linker supports a large TOC.])
5056 AC_CACHE_CHECK(linker --build-id support,
5058 [gcc_cv_ld_buildid=no
5059 if test $in_tree_ld = yes ; then
5060 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5061 "$gcc_cv_gld_minor_version" -ge 18 -o \
5062 "$gcc_cv_gld_major_version" -gt 2 \
5063 && test $in_tree_ld_is_elf = yes; then
5064 gcc_cv_ld_buildid=yes
5066 elif test x$gcc_cv_ld != x; then
5067 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5068 gcc_cv_ld_buildid=yes
5071 if test x"$gcc_cv_ld_buildid" = xyes; then
5072 AC_DEFINE(HAVE_LD_BUILDID, 1,
5073 [Define if your linker supports --build-id.])
5076 AC_ARG_ENABLE(linker-build-id,
5077 [AS_HELP_STRING([--enable-linker-build-id],
5078 [compiler will always pass --build-id to linker])],
5080 enable_linker_build_id=no)
5082 if test x"$enable_linker_build_id" = xyes; then
5083 if test x"$gcc_cv_ld_buildid" = xyes; then
5084 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5085 [Define if gcc should always pass --build-id to linker.])
5087 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5091 # In binutils 2.21, GNU ld gained support for new emulations fully
5092 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5093 AC_CACHE_CHECK(linker *_sol2 emulation support,
5094 gcc_cv_ld_sol2_emulation,
5095 [gcc_cv_ld_sol2_emulation=no
5096 if test $in_tree_ld = yes ; then
5097 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5098 "$gcc_cv_gld_minor_version" -ge 21 -o \
5099 "$gcc_cv_gld_major_version" -gt 2 \
5100 && test $in_tree_ld_is_elf = yes; then
5101 gcc_cv_ld_sol2_emulation=yes
5103 elif test x$gcc_cv_ld != x; then
5104 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5105 grep _sol2 > /dev/null; then
5106 gcc_cv_ld_sol2_emulation=yes
5109 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5110 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5111 [Define if your linker supports the *_sol2 emulations.])
5114 AC_CACHE_CHECK(linker --sysroot support,
5116 [gcc_cv_ld_sysroot=no
5117 if test $in_tree_ld = yes ; then
5118 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
5119 gcc_cv_ld_sysroot=yes
5121 elif test x$gcc_cv_ld != x; then
5122 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5123 gcc_cv_ld_sysroot=yes
5126 if test x"$gcc_cv_ld_sysroot" = xyes; then
5127 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5128 [Define if your linker supports --sysroot.])
5131 # Test for stack protector support in target C library.
5132 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5133 gcc_cv_libc_provides_ssp,
5134 [gcc_cv_libc_provides_ssp=no
5136 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5137 # glibc 2.4 and later provides __stack_chk_fail and
5138 # either __stack_chk_guard, or TLS access to stack guard canary.
5139 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5140 [if test -f $target_header_dir/features.h \
5141 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5142 $target_header_dir/features.h > /dev/null; then
5143 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5144 $target_header_dir/features.h > /dev/null && \
5145 test -f $target_header_dir/bits/uClibc_config.h && \
5146 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5147 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5148 gcc_cv_libc_provides_ssp=yes
5150 # all versions of Bionic support stack protector
5151 elif test -f $target_header_dir/sys/cdefs.h \
5152 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5153 $target_header_dir/sys/cdefs.h > /dev/null; then
5154 gcc_cv_libc_provides_ssp=yes
5158 # Avoid complicated tests (see
5159 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5160 # simply assert that glibc does provide this, which is true for all
5161 # realistically usable GNU/Hurd configurations.
5162 gcc_cv_libc_provides_ssp=yes;;
5163 *-*-darwin* | *-*-freebsd*)
5164 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5165 [echo "no __stack_chk_fail on this target"])
5167 *) gcc_cv_libc_provides_ssp=no ;;
5170 if test x$gcc_cv_libc_provides_ssp = xyes; then
5171 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5172 [Define if your target C library provides stack protector support])
5175 # Test for <sys/sdt.h> on the target.
5176 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5177 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5179 if test -f $target_header_dir/sys/sdt.h; then
5181 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5182 [Define if your target C library provides sys/sdt.h])
5184 AC_MSG_RESULT($have_sys_sdt_h)
5186 # Check if TFmode long double should be used by default or not.
5187 # Some glibc targets used DFmode long double, but with glibc 2.4
5188 # and later they can use TFmode.
5190 powerpc*-*-linux* | \
5194 AC_ARG_WITH(long-double-128,
5195 [AS_HELP_STRING([--with-long-double-128],
5196 [use 128-bit long double by default])],
5197 gcc_cv_target_ldbl128="$with_long_double_128",
5198 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5199 [gcc_cv_target_ldbl128=no
5200 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5201 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5202 && gcc_cv_target_ldbl128=yes
5206 if test x$gcc_cv_target_ldbl128 = xyes; then
5207 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5208 [Define if TFmode long double should be the default])
5211 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5212 gcc_cv_target_dl_iterate_phdr=unknown
5214 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5215 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5216 # libdl there, both complicating its use and breaking compatibility
5217 # between Solaris 10 updates.
5218 *-*-solaris2.1[[1-9]]*)
5219 # <link.h> needs both a dl_iterate_phdr declaration and support for
5220 # compilation with largefile support.
5221 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5222 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5223 gcc_cv_target_dl_iterate_phdr=yes
5225 gcc_cv_target_dl_iterate_phdr=no
5229 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5230 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5231 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5232 [Define if your target C library provides the `dl_iterate_phdr' function.])
5234 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5236 # We no longer support different GC mechanisms. Emit an error if
5237 # the user configures with --with-gc.
5239 [AS_HELP_STRING([--with-gc={page,zone}],
5240 [this option is not supported anymore. It used to choose
5241 the garbage collection mechanism to use with the compiler])],
5242 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5245 # Libraries to use on the host. This will normally be set by the top
5246 # level Makefile. Here we simply capture the value for our Makefile.
5247 if test -z "${HOST_LIBS+set}"; then
5252 # Use the system's zlib library.
5254 zlibinc="-I\$(srcdir)/../zlib"
5255 AC_ARG_WITH(system-zlib,
5256 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5263 dnl Very limited version of automake's enable-maintainer-mode
5265 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5266 dnl maintainer-mode is disabled by default
5267 AC_ARG_ENABLE(maintainer-mode,
5268 [AS_HELP_STRING([--enable-maintainer-mode],
5269 [enable make rules and dependencies not useful
5270 (and sometimes confusing) to the casual installer])],
5271 maintainer_mode=$enableval,
5274 AC_MSG_RESULT($maintainer_mode)
5276 if test "$maintainer_mode" = "yes"; then
5283 dnl Whether to prevent multiple front-ends from linking at the same time
5285 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5286 AC_ARG_ENABLE(link-mutex,
5287 [AS_HELP_STRING([--enable-link-mutex],
5288 [avoid linking multiple front-ends at once to avoid thrashing
5289 on the build machine])],
5290 do_link_mutex=$enableval,
5292 AC_MSG_RESULT($do_link_mutex)
5294 if test "$do_link_mutex" = "yes"; then
5299 AC_SUBST(DO_LINK_MUTEX)
5305 # Make empty files to contain the specs and options for each language.
5306 # Then add #include lines to for a compiler that has specs and/or options.
5312 # These (without "all_") are set in each config-lang.in.
5313 # `language' must be a single word so is spelled singularly.
5316 all_outputs='Makefile'
5317 # List of language makefile fragments.
5319 # Additional files for gengtype
5320 all_gtfiles="$target_gtfiles"
5322 # These are the languages that are set in --enable-languages,
5323 # and are available in the GCC tree.
5324 all_selected_languages=
5326 # Add the language fragments.
5327 # Languages are added via two mechanisms. Some information must be
5328 # recorded in makefile variables, these are defined in config-lang.in.
5329 # We accumulate them and plug them into the main Makefile.
5330 # The other mechanism is a set of hooks for each of the main targets
5331 # like `clean', `install', etc.
5333 language_hooks="Make-hooks"
5335 for lang in ${srcdir}/*/config-lang.in
5338 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5340 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5341 if test "x$lang_alias" = x
5343 echo "$lang doesn't set \$language." 1>&2
5346 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5347 subdirs="$subdirs $subdir"
5349 # $gcc_subdir is where the gcc integration files are to be found
5350 # for a language, both for internal compiler purposes (compiler
5351 # sources implementing front-end to GCC tree converters), and for
5352 # build infrastructure purposes (Make-lang.in, etc.)
5354 # This will be <subdir> (relative to $srcdir) if a line like
5355 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5356 # is found in <langdir>/config-lang.in, and will remain <langdir>
5359 # Except for the language alias (fetched above), the regular
5360 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5361 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5362 # only this and the language alias.
5364 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5365 if [ "$gcc_subdir" = "" ]; then
5366 gcc_subdir="$subdir"
5369 case ",$enable_languages," in
5371 all_selected_languages="$all_selected_languages $lang_alias"
5372 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5373 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5385 . ${srcdir}/$gcc_subdir/config-lang.in
5386 if test "x$language" = x
5388 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5393 case ",$enable_languages," in
5396 for i in $subdir_requires; do
5397 test -f "${srcdir}/$i/config-lang.in" && continue
5405 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5406 if test -f $srcdir/$gcc_subdir/lang.opt; then
5407 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5408 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5410 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5411 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5413 all_languages="$all_languages $language"
5414 all_compilers="$all_compilers $compilers"
5415 all_outputs="$all_outputs $outputs"
5416 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5417 case ",$enable_languages," in
5419 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5421 AC_SUBST(enable_lto)
5428 for language in $all_selected_languages
5430 check_languages="$check_languages check-$language"
5433 # We link each language in with a set of hooks, reached indirectly via
5434 # lang.${target}. Only do so for selected languages.
5438 target_list="all.cross start.encap rest.encap tags \
5439 install-common install-man install-info install-pdf install-html dvi \
5440 pdf html uninstall info man srcextra srcman srcinfo \
5441 mostlyclean clean distclean maintainer-clean install-plugin"
5443 for t in $target_list
5446 for lang in $all_selected_languages
5450 echo "lang.$t: $x" >> Make-hooks
5454 # Option include files
5457 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5458 option_includes="option-includes.mk"
5459 AC_SUBST_FILE(option_includes)
5467 echo "dir ." > .gdbinit
5468 echo "dir ${srcdir}" >> .gdbinit
5469 if test x$gdb_needs_out_file_path = xyes
5471 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5473 if test "x$subdirs" != x; then
5476 echo "dir ${srcdir}/$s" >> .gdbinit
5479 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5480 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5482 # Put a breakpoint on __asan_report_error to help with debugging buffer
5485 *-fsanitize=address*)
5486 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5490 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5491 AC_SUBST(gcc_tooldir)
5494 # Find a directory in which to install a shared libgcc.
5496 AC_ARG_ENABLE(version-specific-runtime-libs,
5497 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5498 [specify that runtime libraries should be
5499 installed in a compiler-specific directory])])
5501 # Set default prefix canonicalization.
5503 AC_ARG_ENABLE(canonical-prefixes,
5504 [ --enable-canonical-prefixes
5505 enable or disable prefix canonicalization],
5507 enable_canonical_prefixes=yes)
5508 if test x"$enable_canonical_prefixes" = xyes; then
5509 AC_DEFINE(ENABLE_CANONICAL_PREFIXES,
5510 1, [Define to enable prefix canonicalization.])
5513 AC_ARG_ENABLE([poison-system-directories],
5514 AS_HELP_STRING([--enable-poison-system-directories],
5515 [warn for use of native system header directories]),,
5516 [enable_poison_system_directories=no])
5517 if test "x${enable_poison_system_directories}" = "xyes"; then
5518 AC_DEFINE([ENABLE_POISON_SYSTEM_DIRECTORIES],
5520 [Define to warn for use of native system header directories])
5523 # Substitute configuration variables
5526 AC_SUBST(all_compilers)
5527 AC_SUBST(all_gtfiles)
5528 AC_SUBST(all_lang_makefrags)
5529 AC_SUBST(all_languages)
5530 AC_SUBST(all_selected_languages)
5531 AC_SUBST(build_exeext)
5532 AC_SUBST(build_install_headers_dir)
5533 AC_SUBST(build_xm_file_list)
5534 AC_SUBST(build_xm_include_list)
5535 AC_SUBST(build_xm_defines)
5536 AC_SUBST(build_file_translate)
5537 AC_SUBST(check_languages)
5538 AC_SUBST(cpp_install_dir)
5539 AC_SUBST(xmake_file)
5540 AC_SUBST(tmake_file)
5541 AC_SUBST(TM_ENDIAN_CONFIG)
5542 AC_SUBST(TM_MULTILIB_CONFIG)
5543 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5544 AC_SUBST(extra_gcc_objs)
5545 AC_SUBST(user_headers_inc_next_pre)
5546 AC_SUBST(user_headers_inc_next_post)
5547 AC_SUBST(extra_headers_list)
5548 AC_SUBST(extra_objs)
5549 AC_SUBST(extra_programs)
5550 AC_SUBST(float_h_file)
5551 AC_SUBST(gcc_config_arguments)
5552 AC_SUBST(gcc_gxx_include_dir)
5553 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5554 AC_SUBST(host_exeext)
5555 AC_SUBST(host_xm_file_list)
5556 AC_SUBST(host_xm_include_list)
5557 AC_SUBST(host_xm_defines)
5558 AC_SUBST(out_host_hook_obj)
5560 AC_SUBST(lang_opt_files)
5561 AC_SUBST(lang_specs_files)
5562 AC_SUBST(lang_tree_files)
5563 AC_SUBST(local_prefix)
5565 AC_SUBST(objc_boehm_gc)
5567 AC_SUBST(out_object_file)
5568 AC_SUBST(common_out_file)
5569 AC_SUBST(common_out_object_file)
5570 AC_SUBST(tm_file_list)
5571 AC_SUBST(tm_include_list)
5572 AC_SUBST(tm_defines)
5573 AC_SUBST(tm_p_file_list)
5574 AC_SUBST(tm_p_include_list)
5575 AC_SUBST(xm_file_list)
5576 AC_SUBST(xm_include_list)
5577 AC_SUBST(xm_defines)
5578 AC_SUBST(use_gcc_stdint)
5579 AC_SUBST(c_target_objs)
5580 AC_SUBST(cxx_target_objs)
5581 AC_SUBST(fortran_target_objs)
5582 AC_SUBST(target_cpu_default)
5584 AC_SUBST_FILE(language_hooks)
5587 if test x${build} = x${host} ; then
5588 if test x${host} = x${target} ; then
5589 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5591 echo "Links are now set up to build a cross-compiler" 1>&2
5592 echo " from ${host} to ${target}." 1>&2
5595 if test x${host} = x${target} ; then
5596 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5597 echo " for ${target}." 1>&2
5599 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5600 echo " from ${host} to ${target}." 1>&2
5604 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5605 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5607 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5608 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5610 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5611 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5612 if test "x${CLOOGLIBS}" != "x" ; then
5613 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5615 # Check whether isl_schedule_constraints_compute_schedule is available;
5616 # it's new in ISL-0.13.
5617 saved_CFLAGS="$CFLAGS"
5618 CFLAGS="$CFLAGS $ISLINC"
5620 LIBS="$LIBS $CLOOGLIBS $ISLLIBS $GMPLIBS"
5622 AC_MSG_CHECKING([Checking for isl_schedule_constraints_compute_schedule])
5623 AC_TRY_LINK([#include <isl/schedule.h>],
5624 [isl_schedule_constraints_compute_schedule (NULL);],
5625 [ac_has_isl_schedule_constraints_compute_schedule=yes],
5626 [ac_has_isl_schedule_constraints_compute_schedule=no])
5627 AC_MSG_RESULT($ac_has_isl_schedule_constraints_compute_schedule)
5630 CFLAGS="$saved_CFLAGS"
5632 if test x"$ac_has_isl_schedule_constraints_compute_schedule" = x"yes"; then
5633 AC_DEFINE(HAVE_ISL_SCHED_CONSTRAINTS_COMPUTE_SCHEDULE, 1,
5634 [Define if isl_schedule_constraints_compute_schedule exists.])
5639 # Check for plugin support
5640 AC_ARG_ENABLE(plugin,
5641 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5642 enable_plugin=$enableval,
5643 enable_plugin=yes; default_plugin=yes)
5649 if test x$build = x$host; then
5650 export_sym_check="nm${exeext} -g"
5651 elif test x$host = x$target; then
5652 export_sym_check="$gcc_cv_nm -g"
5658 if test x$build = x$host; then
5659 export_sym_check="objdump${exeext} -T"
5660 elif test x$host = x$target; then
5661 export_sym_check="$gcc_cv_objdump -T"
5668 if test x"$enable_plugin" = x"yes"; then
5670 AC_MSG_CHECKING([for exported symbols])
5671 if test "x$export_sym_check" != x; then
5672 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5673 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5674 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5675 : # No need to use a flag
5676 AC_MSG_RESULT([yes])
5678 AC_MSG_RESULT([yes])
5679 AC_MSG_CHECKING([for -rdynamic])
5680 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5681 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5683 pluginlibs="-rdynamic"
5688 AC_MSG_RESULT([$plugin_rdynamic])
5691 AC_MSG_RESULT([unable to check])
5696 AC_SEARCH_LIBS([dlopen], [dl])
5697 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5698 pluginlibs="$pluginlibs -ldl"
5702 # Check that we can build shared objects with -fPIC -shared
5703 saved_LDFLAGS="$LDFLAGS"
5704 saved_CFLAGS="$CFLAGS"
5707 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5708 CFLAGS="$CFLAGS -fPIC"
5709 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5712 CFLAGS="$CFLAGS -fPIC"
5713 LDFLAGS="$LDFLAGS -fPIC -shared"
5716 AC_MSG_CHECKING([for -fPIC -shared])
5718 [extern int X;],[return X == 0;],
5719 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5720 [AC_MSG_RESULT([no]); have_pic_shared=no])
5721 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5725 LDFLAGS="$saved_LDFLAGS"
5726 CFLAGS="$saved_CFLAGS"
5728 # If plugin support had been requested but not available, fail.
5729 if test x"$enable_plugin" = x"no" ; then
5730 if test x"$default_plugin" != x"yes"; then
5732 Building GCC with plugin support requires a host that supports
5733 -fPIC, -shared, -ldl and -rdynamic.])
5738 AC_SUBST(pluginlibs)
5739 AC_SUBST(enable_plugin)
5740 if test x"$enable_plugin" = x"yes"; then
5741 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5745 # Enable --enable-host-shared
5746 AC_ARG_ENABLE(host-shared,
5747 [AS_HELP_STRING([--enable-host-shared],
5748 [build host code as shared libraries])],
5749 [PICFLAG=-fPIC], [PICFLAG=])
5750 AC_SUBST(enable_host_shared)
5754 AC_ARG_ENABLE(libquadmath-support,
5755 [AS_HELP_STRING([--disable-libquadmath-support],
5756 [disable libquadmath support for Fortran])],
5757 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5758 ENABLE_LIBQUADMATH_SUPPORT=yes)
5759 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5760 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5761 [Define to 1 to enable libquadmath support])
5765 warn_frame_larger_than_extra_text=
5766 AC_ARG_WITH(warn-frame-larger-than-extra-text,
5767 [ --with-warn-frame-larger-than-extra-text=TEXT
5768 specifies extra text for frame size warnings],
5769 [case "${withval}" in
5770 yes) AC_MSG_ERROR(bad value ${withval} given for frame size warning text) ;;
5772 *) warn_frame_larger_than_extra_text="$withval" ;;
5774 AC_DEFINE_UNQUOTED(WARN_FRAME_LARGER_THAN_EXTRA_TEXT,
5775 "$warn_frame_larger_than_extra_text",
5776 [Define to be extra text for frame size warnings.])
5779 # Specify what hash style to use by default.
5780 AC_ARG_WITH([linker-hash-style],
5781 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5782 [specify the linker hash style])],
5783 [case x"$withval" in
5785 LINKER_HASH_STYLE=sysv
5788 LINKER_HASH_STYLE=gnu
5791 LINKER_HASH_STYLE=both
5794 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5797 [LINKER_HASH_STYLE=''])
5798 if test x"${LINKER_HASH_STYLE}" != x; then
5799 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5800 [The linker hash style])
5803 # Configure the subdirectories
5804 # AC_CONFIG_SUBDIRS($subdirs)
5806 # Create the Makefile
5807 # and configure language subdirectories
5808 AC_CONFIG_FILES($all_outputs)
5810 AC_CONFIG_COMMANDS([default],
5812 case ${CONFIG_HEADERS} in
5813 *auto-host.h:config.in*)
5816 # Make sure all the subdirs exist.
5817 for d in $subdirs doc build common c-family
5819 test -d $d || mkdir $d
5822 [subdirs='$subdirs'])