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
717 AC_ARG_WITH([upc-pts],
719 [--with-upc-pts={struct,packed}],
720 [choose the representation of a UPC pointer-to-shared]),
723 packed|struct) upc_pts_rep="$withval" ;;
724 *) AC_MSG_ERROR([$withval is an invalid option to --with-upc-pts])
728 [upc_pts_rep="packed"])
731 # Perl is required for checking pts representation
732 AC_CHECK_PROG(PERL, perl, perl)
734 AC_ARG_WITH([upc-pts-vaddr-order],
736 [--with-upc-pts-vaddr-order={last,first}],
737 [choose position of the address field in UPC pointer-to-shared representation]),
739 upc_vaddr_order="$withval"
740 case "$upc_vaddr_order" in
743 [$withval is an invalid option to --with-upc-pts-vaddr-order]) ;;
746 [upc_vaddr_order="first"])
748 AC_ARG_WITH([upc-pts-packed-bits],
750 [--with-upc-pts-packed-bits=phase,thread,vaddr],
751 [choose bit distribution in packed UPC pointer-to-shared representation]),
753 if test x"$upc_pts_rep" = x"packed"; then
754 UPC_PTS_PHASE_SIZE=`echo "$withval" | $PERL -ne 'm/^(\d+),(\d+),(\d+)$/;
755 print $1 if ($1+$2+$3 == 64) && $1>=1;'`
756 UPC_PTS_THREAD_SIZE=`echo "$withval" | $PERL -ne 'm/^(\d+),(\d+),(\d+)$/;
757 print $2 if ($1+$2+$3 == 64) && $2>=1;'`
758 UPC_PTS_VADDR_SIZE=`echo "$withval" | $PERL -ne 'm/^(\d+),(\d+),(\d+)$/;
759 print $3 if ($1+$2+$3 == 64) && $3>=20;'`
760 if test -z "$UPC_PTS_PHASE_SIZE" \
761 || test -z "$UPC_PTS_THREAD_SIZE" \
762 || test -z "$UPC_PTS_VADDR_SIZE" ; then
763 AC_MSG_ERROR([--with-upc-pts-packed-bits=phase,thread,vaddr requires
764 phase+thread+vaddr=64 and phase >= 1 and thread >= 1 and vaddr >= 20])
767 AC_MSG_ERROR([--with-upc-pts-packed-bits is only supported for
768 the packed UPC pointer-to-shared representation])
772 # GNU UPC packed pointer representation defaults.
775 UPC_PTS_PHASE_SIZE=20
776 UPC_PTS_THREAD_SIZE=12
777 UPC_PTS_VADDR_SIZE=32
780 UPC_PTS_PHASE_SIZE=20
781 UPC_PTS_THREAD_SIZE=10
782 UPC_PTS_VADDR_SIZE=34
786 AC_ARG_ENABLE(upc-link-script,
788 [--enable-upc-link-script],
789 [enable UPC's use of a custom linker script;
790 this will define the UPC shared section as a no load section on
791 targets where this feature is supported (requires GNU LD)]),
796 AC_MSG_ERROR([--enable-upc-link-script accepts only yes or no.])
799 [enable_upc_link_script=no])
802 # Process UPC-specific configuration options.
804 AC_MSG_CHECKING([for UPC pointer-to-shared representation])
805 AC_MSG_RESULT([$upc_pts_rep])
806 case "$upc_pts_rep" in
808 AC_DEFINE(HAVE_UPC_PTS_PACKED_REP,[1],
809 [Define to 1 if UPC pointer-to-shared representation
810 is a packed 64 bit word.])
813 AC_DEFINE(HAVE_UPC_PTS_STRUCT_REP,[1],
814 [Define to 1 if UPC pointer-to-shared representation
818 AC_MSG_CHECKING([for UPC pointer-to-shared address field position])
819 AC_MSG_RESULT([$upc_vaddr_order])
820 if test x"$upc_vaddr_order" = x"first"; then
821 AC_DEFINE(HAVE_UPC_PTS_VADDR_FIRST,[1],
822 [Define to 1 if the 'vaddr' field is the first field
823 in the UPC pointer-to-shared representation.])
825 if test x"$upc_pts_rep" = x"packed"; then
826 AC_DEFINE_UNQUOTED(UPC_PTS_PHASE_SIZE,$UPC_PTS_PHASE_SIZE,
827 [For packed UPC pointers-to-shared,
828 the size of the phase field (in bits).])
829 AC_DEFINE_UNQUOTED(UPC_PTS_THREAD_SIZE,$UPC_PTS_THREAD_SIZE,
830 [For packed UPC pointers-to-shared,
831 the size of the thread field (in bits).])
832 AC_DEFINE_UNQUOTED(UPC_PTS_VADDR_SIZE,$UPC_PTS_VADDR_SIZE,
833 [For packed UPC pointers-to-shared,
834 the size of the address field (in bits).])
835 AC_MSG_CHECKING([for packed UPC pointer-to-shared layout])
837 ["phase=${UPC_PTS_PHASE_SIZE},thread=${UPC_PTS_THREAD_SIZE},
838 vaddr=${UPC_PTS_VADDR_SIZE}"])
840 AC_MSG_CHECKING([for UPC link script support])
841 AC_MSG_RESULT($enable_upc_link_script)
842 if test "$enable_upc_link_script" = yes; then
843 AC_DEFINE(HAVE_UPC_LINK_SCRIPT, 1, [Define to 1 if UPC link script is supported.])
847 [AS_HELP_STRING([--with-dwarf2], [force the default debug format to be DWARF 2])],
848 dwarf2="$with_dwarf2",
851 AC_ARG_ENABLE(shared,
852 [AS_HELP_STRING([--disable-shared], [don't provide a shared libgcc])],
854 case $enable_shared in
858 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
859 for pkg in $enableval; do
860 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
867 ], [enable_shared=yes])
868 AC_SUBST(enable_shared)
870 AC_ARG_WITH([native-system-header-dir],
871 [ --with-native-system-header-dir=dir
872 use dir as the directory to look for standard
873 system header files in. Defaults to /usr/include.],
875 case ${with_native_system_header_dir} in
876 yes|no) AC_MSG_ERROR([bad value ${withval} given for --with-native-system-header-dir]) ;;
877 /* | [[A-Za-z]]:[[\\/]]*) ;;
878 *) AC_MSG_ERROR([--with-native-system-header-dir argument ${withval} must be an absolute directory]) ;;
880 configured_native_system_header_dir="${withval}"
881 ], [configured_native_system_header_dir=])
883 AC_ARG_WITH(build-sysroot,
884 [AS_HELP_STRING([--with-build-sysroot=sysroot],
885 [use sysroot as the system root during the build])],
886 [if test x"$withval" != x ; then
887 SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
889 [SYSROOT_CFLAGS_FOR_TARGET=])
890 AC_SUBST(SYSROOT_CFLAGS_FOR_TARGET)
892 if test "x$prefix" = xNONE; then
893 test_prefix=/usr/local
897 if test "x$exec_prefix" = xNONE; then
898 test_exec_prefix=$test_prefix
900 test_exec_prefix=$exec_prefix
904 [AS_HELP_STRING([[--with-sysroot[=DIR]]],
905 [search for usr/lib, usr/include, et al, within DIR])],
907 case ${with_sysroot} in
908 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
909 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
912 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
913 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
915 case ${TARGET_SYSTEM_ROOT} in
916 "${test_prefix}"|"${test_prefix}/"*|\
917 "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
918 '${prefix}'|'${prefix}/'*|\
919 '${exec_prefix}'|'${exec_prefix}/'*)
920 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
921 TARGET_SYSTEM_ROOT_DEFINE="$t"
926 TARGET_SYSTEM_ROOT_DEFINE=
927 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
929 AC_SUBST(TARGET_SYSTEM_ROOT)
930 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
931 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
934 [AS_HELP_STRING([--with-specs=SPECS],
935 [add SPECS to driver command-line processing])],
936 [CONFIGURE_SPECS=$withval],
939 AC_SUBST(CONFIGURE_SPECS)
941 ACX_PKGVERSION([GCC])
942 ACX_BUGURL([http://gccupc.org/bugs])
944 # Sanity check enable_languages in case someone does not run the toplevel
945 # configure # script.
946 AC_ARG_ENABLE(languages,
947 [AS_HELP_STRING([--enable-languages=LIST], [specify which front-ends to build])],
948 [case ,${enable_languages}, in
950 # go safe -- we cannot be much sure without the toplevel
952 # analysis of which target libs are present and usable
956 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
961 enable_languages=c,${enable_languages}
964 [enable_languages=c])
966 AC_ARG_WITH(multilib-list,
967 [AS_HELP_STRING([--with-multilib-list], [select multilibs (AArch64, SH and x86-64 only)])],
969 with_multilib_list=default)
971 # -------------------------
972 # Checks for other programs
973 # -------------------------
977 # Find some useful tools
979 # We need awk to create options.c and options.h.
980 # Bail out if it's missing.
982 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
989 AC_SUBST(ranlib_flags)
993 # See if cmp has --ignore-initial.
994 gcc_AC_PROG_CMP_IGNORE_INITIAL
996 # See if we have the mktemp command.
997 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
999 # See if makeinfo has been installed and is modern enough
1000 # that we can use it.
1001 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
1002 [GNU texinfo.* \([0-9][0-9.]*\)],
1003 [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
1004 if test $gcc_cv_prog_makeinfo_modern = no; then
1006 *** Makeinfo is missing or too old.
1007 *** Info documentation will not be built.])
1012 AC_SUBST(BUILD_INFO)
1014 # Is pod2man recent enough to regenerate manpages?
1015 AC_MSG_CHECKING([for recent Pod::Man])
1016 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
1018 GENERATED_MANPAGES=generated-manpages
1023 AC_SUBST(GENERATED_MANPAGES)
1025 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
1028 dnl Don't use AC_PROG_LEX; we insist on flex.
1029 dnl LEXLIB is not useful in gcc.
1030 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
1033 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
1035 # Binutils are not build modules, unlike bison/flex/makeinfo. So we
1036 # check for build == host before using them.
1039 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
1040 && test -d ../binutils ; then
1041 NM='${objdir}/../binutils/nm-new'
1043 AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
1047 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
1048 && test -d ../binutils ; then
1049 AR='${objdir}/../binutils/ar'
1051 AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
1055 # --------------------
1056 # Checks for C headers
1057 # --------------------
1059 # Need to reject headers which give warnings, so that the -Werror bootstrap
1060 # works later. *sigh* This needs to come before all header checks.
1067 AC_HEADER_TIOCGWINSZ
1068 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
1069 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
1070 sys/resource.h sys/param.h sys/times.h sys/stat.h \
1071 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
1073 # Check for thread headers.
1074 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
1075 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
1077 # These tests can't be done till we know if we have limits.h.
1081 # ----------------------
1082 # Checks for C++ headers
1083 # ----------------------
1085 dnl Autoconf will give an error in the configure script if there is no
1086 dnl C++ preprocessor. Hack to prevent that.
1087 m4_pushdef([AC_MSG_ERROR], m4_defn([AC_MSG_WARN]))[]dnl
1089 m4_popdef([AC_MSG_ERROR])[]dnl
1093 AC_CHECK_HEADERS(unordered_map)
1094 AC_CHECK_HEADERS(tr1/unordered_map)
1095 AC_CHECK_HEADERS(ext/hash_map)
1100 # Dependency checking.
1105 AC_CONFIG_COMMANDS([gccdepdir],[
1106 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs build/$DEPDIR
1107 for lang in $subdirs c-family common
1109 ${CONFIG_SHELL-/bin/sh} $ac_aux_dir/mkinstalldirs $lang/$DEPDIR
1110 done], [subdirs="$subdirs" ac_aux_dir=$ac_aux_dir DEPDIR=$DEPDIR])
1112 ZW_PROG_COMPILER_DEPENDENCIES([CXX])
1120 # These libraries may be used by collect2.
1121 # We may need a special search path to get them linked.
1122 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
1124 for libs in '' -lld -lmld \
1125 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
1126 '-L/usr/lib/cmplrs/cc3.11 -lmld'
1129 AC_TRY_LINK_FUNC(ldopen,
1130 [gcc_cv_collect2_libs="$libs"; break])
1133 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
1134 case $gcc_cv_collect2_libs in
1136 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
1138 AC_SUBST(COLLECT2_LIBS)
1140 # When building Ada code on Alpha, we need exc_resume which is usually in
1141 # -lexc. So test for it.
1144 AC_SEARCH_LIBS(exc_resume, exc)
1147 AC_SUBST(GNAT_LIBEXC)
1149 # To support -mcpu=native on Solaris/SPARC, we need libkstat.
1152 AC_SEARCH_LIBS(kstat_open, kstat)
1153 EXTRA_GCC_LIBS="$LIBS"
1155 AC_SUBST(EXTRA_GCC_LIBS)
1157 # Some systems put ldexp and frexp in libm instead of libc; assume
1158 # they're both in the same place. jcf-dump needs them.
1161 AC_SEARCH_LIBS(ldexp, m)
1166 # Use <inttypes.h> only if it exists,
1167 # doesn't clash with <sys/types.h>, and declares intmax_t.
1168 AC_MSG_CHECKING(for inttypes.h)
1169 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
1170 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1171 [[#include <sys/types.h>
1172 #include <inttypes.h>]],
1173 [[intmax_t i = -1;]])],
1174 [gcc_cv_header_inttypes_h=yes],
1175 [gcc_cv_header_inttypes_h=no])])
1176 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
1177 if test $gcc_cv_header_inttypes_h = yes; then
1178 AC_DEFINE(HAVE_INTTYPES_H, 1,
1179 [Define if you have a working <inttypes.h> header file.])
1182 dnl Disabled until we have a complete test for buggy enum bitfields.
1183 dnl gcc_AC_C_ENUM_BF_UNSIGNED
1185 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
1186 ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
1187 fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
1188 fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
1189 putchar_unlocked putc_unlocked)
1190 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1191 sysconf strsignal getrusage nl_langinfo \
1192 gettimeofday mbstowcs wcswidth mmap setlocale \
1193 gcc_UNLOCKED_FUNCS madvise)
1195 if test x$ac_cv_func_mbstowcs = xyes; then
1196 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1197 [ AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1203 [gcc_cv_func_mbstowcs_works=yes],
1204 [gcc_cv_func_mbstowcs_works=no],
1205 [gcc_cv_func_mbstowcs_works=yes])])
1206 if test x$gcc_cv_func_mbstowcs_works = xyes; then
1207 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1208 [Define this macro if mbstowcs does not crash when its
1209 first argument is NULL.])
1213 AC_CHECK_TYPE(ssize_t, int)
1214 AC_CHECK_TYPE(caddr_t, char *)
1216 GCC_AC_FUNC_MMAP_BLACKLIST
1220 # Under VMS, vfork works very differently than on Unix. The standard test
1221 # won't work, and it isn't easily adaptable. It makes more sense to
1223 ac_cv_func_vfork_works=yes
1228 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which exposes a different
1229 # iconv() prototype.
1234 # Until we have in-tree GNU iconv:
1236 AC_SUBST(LIBICONV_DEP)
1242 # We will need to find libiberty.h and ansidecl.h
1243 saved_CFLAGS="$CFLAGS"
1244 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1245 saved_CXXFLAGS="$CXXFLAGS"
1246 CXXFLAGS="$CXXFLAGS -I${srcdir} -I${srcdir}/../include $GMPINC"
1247 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1248 strsignal strstr stpcpy strverscmp \
1249 errno snprintf vsnprintf vasprintf malloc realloc calloc \
1250 free basename getopt clock getpagesize ffs gcc_UNLOCKED_FUNCS, , ,[
1251 #include "ansidecl.h"
1252 #include "system.h"])
1254 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1255 #include "ansidecl.h"
1257 #ifdef HAVE_SYS_RESOURCE_H
1258 #include <sys/resource.h>
1262 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1263 #include "ansidecl.h"
1265 #ifdef HAVE_SYS_RESOURCE_H
1266 #include <sys/resource.h>
1268 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1269 [Define to `long' if <sys/resource.h> doesn't define.])])
1271 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1272 # FREAD and FWRITE macros. Fortunately, for GCC's single usage of ldgetname
1273 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1274 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1275 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1276 #include "ansidecl.h"
1285 gcc_AC_CHECK_DECLS(times, , ,[
1286 #include "ansidecl.h"
1288 #ifdef HAVE_SYS_TIMES_H
1289 #include <sys/times.h>
1293 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1294 #include "ansidecl.h"
1299 # g++ on Solaris 10+ defines _XOPEN_SOURCE=600, which hides the madvise()
1302 gcc_AC_CHECK_DECLS(madvise, , ,[
1303 #include "ansidecl.h"
1308 # More time-related stuff.
1309 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1310 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1311 #include "ansidecl.h"
1313 #ifdef HAVE_SYS_TIMES_H
1314 #include <sys/times.h>
1316 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1317 if test $ac_cv_struct_tms = yes; then
1318 AC_DEFINE(HAVE_STRUCT_TMS, 1,
1319 [Define if <sys/times.h> defines struct tms.])
1322 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1323 # revisit after autoconf 2.50.
1324 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1325 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1326 #include "ansidecl.h"
1328 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1329 if test $gcc_cv_type_clock_t = yes; then
1330 AC_DEFINE(HAVE_CLOCK_T, 1,
1331 [Define if <time.h> defines clock_t.])
1334 # Check if F_SETLKW is supported by fcntl.
1335 AC_CACHE_CHECK(for F_SETLKW, ac_cv_f_setlkw, [
1336 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1337 #include <fcntl.h>]], [[
1343 return fcntl (1, F_SETLKW, &fl);]])],
1344 [ac_cv_f_setlkw=yes],[ac_cv_f_setlkw=no])])
1345 if test $ac_cv_f_setlkw = yes; then
1346 AC_DEFINE(HOST_HAS_F_SETLKW, 1,
1347 [Define if F_SETLKW supported by fcntl.])
1350 # Restore CFLAGS, CXXFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1351 CFLAGS="$saved_CFLAGS"
1352 CXXFLAGS="$saved_CXXFLAGS"
1354 # mkdir takes a single argument on some systems.
1355 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1363 # With Setjmp/Longjmp based exception handling.
1364 AC_ARG_ENABLE(sjlj-exceptions,
1365 [AS_HELP_STRING([--enable-sjlj-exceptions],
1366 [arrange to use setjmp/longjmp exception handling])],
1369 if test $enableval != yes; then
1370 AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1375 force_sjlj_exceptions=yes],
1378 force_sjlj_exceptions=yes
1382 force_sjlj_exceptions=yes
1386 force_sjlj_exceptions=no
1389 if test $force_sjlj_exceptions = yes; then
1390 sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1391 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1392 [Define 0/1 to force the choice for exception handling model.])
1395 # --------------------------------------------------------
1396 # Build, host, and target specific configuration fragments
1397 # --------------------------------------------------------
1399 # Collect build-machine-specific information.
1400 . ${srcdir}/config.build
1402 # Collect host-machine-specific information.
1403 . ${srcdir}/config.host
1407 # Collect target-machine-specific information.
1408 . ${srcdir}/config.gcc
1410 extra_objs="${host_extra_objs} ${extra_objs}"
1411 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1413 # Default the target-machine variables that were not explicitly set.
1414 if test x"$tm_file" = x
1415 then tm_file=$cpu_type/$cpu_type.h; fi
1417 if test x"$extra_headers" = x
1418 then extra_headers=; fi
1420 if test x$md_file = x
1421 then md_file=$cpu_type/$cpu_type.md; fi
1423 if test x$out_file = x
1424 then out_file=$cpu_type/$cpu_type.c; fi
1426 if test x"$tmake_file" = x
1427 then tmake_file=$cpu_type/t-$cpu_type
1430 # Support --enable-initfini-array.
1431 if test x$enable_initfini_array != xno; then
1432 tm_file="${tm_file} initfini-array.h"
1435 if test x"$dwarf2" = xyes
1436 then tm_file="$tm_file tm-dwarf2.h"
1439 # Say what files are being used for the output code and MD file.
1440 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1441 echo "Using \`$srcdir/config/$md_file' as machine description file."
1443 # If any of the xm_file variables contain nonexistent files, warn
1444 # about them and drop them.
1447 for x in $build_xm_file; do
1448 if test -f $srcdir/config/$x
1450 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1456 for x in $host_xm_file; do
1457 if test -f $srcdir/config/$x
1459 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1465 for x in $xm_file; do
1466 if test -f $srcdir/config/$x
1468 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1474 for f in $tm_file; do
1477 if test $count = ax; then
1478 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1480 echo "Using the following target machine macro files:"
1481 for f in $tm_file; do
1482 echo " $srcdir/config/$f"
1486 if test x$need_64bit_hwint = xyes; then
1487 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1488 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1491 if test x$use_long_long_for_widest_fast_int = xyes; then
1492 AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1493 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1494 efficiently supported by the host hardware.])
1497 gnu_ld_bool=`if test x"$gnu_ld" = x"yes"; then echo 1; else echo 0; fi`
1498 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld_bool, [Define to 1 if using GNU ld.])
1500 gnu_as_bool=`if test x"$gas" = x"yes"; then echo 1; else echo 0; fi`
1501 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as_bool, [Define to 1 if using GNU as.])
1504 for f in $host_xm_file; do
1507 if test $count = a; then
1509 elif test $count = ax; then
1510 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1512 echo "Using the following host machine macro files:"
1513 for f in $host_xm_file; do
1514 echo " $srcdir/config/$f"
1517 echo "Using ${out_host_hook_obj} for host machine hooks."
1519 if test "$host_xm_file" != "$build_xm_file"; then
1521 for f in $build_xm_file; do
1524 if test $count = a; then
1526 elif test $count = ax; then
1527 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1529 echo "Using the following build machine macro files:"
1530 for f in $build_xm_file; do
1531 echo " $srcdir/config/$f"
1536 if test -n "$configured_native_system_header_dir"; then
1537 native_system_header_dir=$configured_native_system_header_dir
1539 NATIVE_SYSTEM_HEADER_DIR="$native_system_header_dir"
1540 AC_SUBST(NATIVE_SYSTEM_HEADER_DIR)
1544 AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1545 gcc_cv_mcontext_underscores,
1547 #include <sys/cdefs.h>
1548 #include <sys/signal.h>
1549 #include <ucontext.h>
1550 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1552 gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1553 if test $gcc_cv_mcontext_underscores = yes; then
1554 AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1555 [mcontext_t fields start with __])
1564 # Check if a valid thread package
1565 case ${enable_threads} in
1568 target_thread_file='single'
1572 target_thread_file='single'
1574 aix | dce | lynx | mipssde | posix | rtems | \
1575 single | tpf | vxworks | win32)
1576 target_thread_file=${enable_threads}
1579 echo "${enable_threads} is an unknown thread package" 1>&2
1584 if test x${thread_file} = x; then
1585 # No thread file set by target-specific clauses in config.gcc,
1586 # so use file chosen by default logic above
1587 thread_file=${target_thread_file}
1595 if test x$enable___cxa_atexit = xyes || \
1596 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1597 if test x$host = x$target; then
1599 # mingw32 doesn't have __cxa_atexit but uses atexit registration
1600 # keyed to flag_use_cxa_atexit
1608 AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1609 [echo "__cxa_atexit can't be enabled on this target"])
1613 # We can't check for __cxa_atexit when building a cross, so assume
1617 if test x$use_cxa_atexit = xyes; then
1618 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1619 [Define if you want to use __cxa_atexit, rather than atexit, to
1620 register C++ destructors for local statics and global objects.
1621 This is essential for fully standards-compliant handling of
1622 destructors, but requires __cxa_atexit in libc.])
1626 # Look for a file containing extra machine modes.
1627 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1628 extra_modes_file='$(srcdir)'/config/${extra_modes}
1629 AC_SUBST(extra_modes_file)
1630 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1631 [Define to the name of a file containing a list of extra machine modes
1632 for this architecture.])
1635 # Convert extra_options into a form suitable for Makefile use.
1638 for f in $extra_options; do
1639 extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1640 all_opt_files="$all_opt_files $srcdir/config/$f"
1642 AC_SUBST(extra_opt_files)
1644 # auto-host.h is the file containing items generated by autoconf and is
1645 # the first file included by config.h.
1646 # If host=build, it is correct to have bconfig include auto-host.h
1647 # as well. If host!=build, we are in error and need to do more
1648 # work to find out the build config parameters.
1649 if test x$host = x$build
1651 build_auto=auto-host.h
1653 # We create a subdir, then run autoconf in the subdir.
1654 # To prevent recursion we set host and build for the new
1655 # invocation of configure to the build for this invocation
1662 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1663 *) realsrcdir=../${srcdir};;
1665 # Clearing GMPINC is necessary to prevent host headers being
1666 # used by the build compiler. Defining GENERATOR_FILE stops
1667 # system.h from including gmp.h.
1668 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1669 CXX="${CXX_FOR_BUILD}" CXXFLAGS="${CXXFLAGS_FOR_BUILD}" \
1670 LD="${LD_FOR_BUILD}" LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1671 GMPINC="" CPPFLAGS="${CPPFLAGS} -DGENERATOR_FILE" \
1672 ${realsrcdir}/configure \
1673 --enable-languages=${enable_languages-all} \
1674 --target=$target_alias --host=$build_alias --build=$build_alias
1676 # We just finished tests for the build machine, so rename
1677 # the file auto-build.h in the gcc directory.
1678 mv auto-host.h ../auto-build.h
1681 build_auto=auto-build.h
1683 AC_SUBST(build_subdir)
1685 tm_file="${tm_file} defaults.h"
1686 tm_p_file="${tm_p_file} tm-preds.h"
1687 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1688 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1689 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1690 # put this back in temporarily.
1691 xm_file="auto-host.h ansidecl.h ${xm_file}"
1698 # Compile in configure arguments.
1699 if test -f configargs.h ; then
1700 # Being re-configured.
1701 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1702 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1704 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1707 # Double all backslashes and backslash all quotes to turn
1708 # gcc_config_arguments into a C string.
1709 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1710 $gcc_config_arguments
1712 gcc_config_arguments_str=`cat conftest.out`
1715 cat > configargs.h <<EOF
1716 /* Generated automatically. */
1717 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1718 static const char thread_model[] = "$thread_file";
1720 static const struct {
1721 const char *name, *value;
1722 } configure_default_options[] = $configure_default_options;
1727 gcc_BASEVER=`cat $srcdir/BASE-VER`
1728 gcc_DEVPHASE=`cat $srcdir/DEV-PHASE`
1729 gcc_DATESTAMP=`cat $srcdir/DATESTAMP`
1730 if test -f $srcdir/REVISION ; then
1731 gcc_REVISION=`cat $srcdir/REVISION`
1735 cat > plugin-version.h <<EOF
1736 #include "configargs.h"
1738 #define GCCPLUGIN_VERSION_MAJOR `echo $gcc_BASEVER | sed -e 's/^\([0-9]*\).*$/\1/'`
1739 #define GCCPLUGIN_VERSION_MINOR `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.\([0-9]*\).*$/\1/'`
1740 #define GCCPLUGIN_VERSION_PATCHLEVEL `echo $gcc_BASEVER | sed -e 's/^[0-9]*\.[0-9]*\.\([0-9]*\)$/\1/'`
1741 #define GCCPLUGIN_VERSION (GCCPLUGIN_VERSION_MAJOR*1000 + GCCPLUGIN_VERSION_MINOR)
1743 static char basever[] = "$gcc_BASEVER";
1744 static char datestamp[] = "$gcc_DATESTAMP";
1745 static char devphase[] = "$gcc_DEVPHASE";
1746 static char revision[] = "$gcc_REVISION";
1748 /* FIXME plugins: We should make the version information more precise.
1749 One way to do is to add a checksum. */
1751 static struct plugin_gcc_version gcc_version = {basever, datestamp,
1753 configuration_arguments};
1757 # Internationalization
1758 ZW_GNU_GETTEXT_SISTER_DIR
1760 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1761 # -liconv on the link line twice.
1762 case "$LIBINTL" in *$LIBICONV*)
1766 AC_ARG_ENABLE(secureplt,
1767 [AS_HELP_STRING([--enable-secureplt],
1768 [enable -msecure-plt by default for PowerPC])],
1771 AC_ARG_ENABLE(leading-mingw64-underscores,
1772 AS_HELP_STRING([--enable-leading-mingw64-underscores],
1773 [enable leading underscores on 64 bit mingw targets]),
1775 AS_IF([ test x"$enable_leading_mingw64_underscores" = xyes ],
1776 [AC_DEFINE(USE_MINGW64_LEADING_UNDERSCORES, 1,
1777 [Define if we should use leading underscore on 64 bit mingw targets])])
1780 [AS_HELP_STRING([--enable-cld], [enable -mcld by default for 32bit x86])], [],
1783 AC_ARG_ENABLE(frame-pointer,
1784 [AS_HELP_STRING([--enable-frame-pointer],
1785 [enable -fno-omit-frame-pointer by default for 32bit x86])], [],
1788 linux* | darwin[[8912]]*)
1789 # Enable -fomit-frame-pointer by default for Linux and Darwin with
1791 enable_frame_pointer=no
1794 enable_frame_pointer=yes
1799 # Windows32 Registry support for specifying GCC installation paths.
1800 AC_ARG_ENABLE(win32-registry,
1801 [AS_HELP_STRING([--disable-win32-registry],
1802 [disable lookup of installation paths in the
1803 Registry on Windows hosts])
1804 AS_HELP_STRING([--enable-win32-registry], [enable registry lookup (default)])
1805 AS_HELP_STRING([--enable-win32-registry=KEY],
1806 [use KEY instead of GCC version as the last portion
1807 of the registry key])],,)
1810 win32 | pe | cygwin* | mingw32* | uwin*)
1811 if test "x$enable_win32_registry" != xno; then
1812 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1815 if test "x$enable_win32_registry" != xno; then
1816 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1817 [Define to 1 if installation paths should be looked up in the Windows
1818 Registry. Ignored on non-Windows hosts.])
1820 if test "x$enable_win32_registry" != xyes \
1821 && test "x$enable_win32_registry" != x; then
1822 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1823 [Define to be the last component of the Windows registry key under which
1824 to look for installation paths. The full key used will be
1825 HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1826 The default is the GCC version number.])
1832 # Get an absolute path to the GCC top-level source directory
1833 holddir=`${PWDCMD-pwd}`
1835 topdir=`${PWDCMD-pwd}`
1838 # Conditionalize the makefile for this host machine.
1840 for f in ${host_xmake_file}
1842 if test -f ${srcdir}/config/$f
1844 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1848 # Conditionalize the makefile for this target machine.
1850 for f in ${tmake_file}
1852 if test -f ${srcdir}/config/$f
1854 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1857 tmake_file="${tmake_file_}"
1859 out_object_file=`basename $out_file .c`.o
1860 common_out_object_file=`basename $common_out_file .c`.o
1862 tm_file_list="options.h"
1863 tm_include_list="options.h insn-constants.h"
1864 for f in $tm_file; do
1867 f=`echo $f | sed 's/^..//'`
1868 tm_file_list="${tm_file_list} $f"
1869 tm_include_list="${tm_include_list} $f"
1872 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1873 tm_include_list="${tm_include_list} $f"
1876 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1877 tm_include_list="${tm_include_list} config/$f"
1884 for f in $tm_p_file; do
1887 tm_p_file_list="${tm_p_file_list} $f"
1888 tm_p_include_list="${tm_p_include_list} $f"
1891 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1892 tm_p_include_list="${tm_p_include_list} config/$f"
1898 for f in $xm_file; do
1901 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1902 xm_include_list="${xm_include_list} $f"
1905 xm_file_list="${xm_file_list} $f"
1906 xm_include_list="${xm_include_list} $f"
1909 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1910 xm_include_list="${xm_include_list} config/$f"
1916 host_xm_include_list=
1917 for f in $host_xm_file; do
1920 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1921 host_xm_include_list="${host_xm_include_list} $f"
1924 host_xm_file_list="${host_xm_file_list} $f"
1925 host_xm_include_list="${host_xm_include_list} $f"
1928 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1929 host_xm_include_list="${host_xm_include_list} config/$f"
1935 for f in $build_xm_file; do
1938 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1939 build_xm_include_list="${build_xm_include_list} $f"
1941 auto-build.h | auto-host.h )
1942 build_xm_file_list="${build_xm_file_list} $f"
1943 build_xm_include_list="${build_xm_include_list} $f"
1946 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1947 build_xm_include_list="${build_xm_include_list} config/$f"
1952 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1953 # cross-compiler which does not use the native headers and libraries.
1954 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1955 CROSS= AC_SUBST(CROSS)
1956 ALL=all.internal AC_SUBST(ALL)
1957 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1959 if test "x$with_build_sysroot" != x; then
1960 build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1962 # This value is used, even on a native system, because
1963 # CROSS_SYSTEM_HEADER_DIR is just
1964 # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1965 build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1968 if test x$host != x$target
1970 CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1972 SYSTEM_HEADER_DIR=$build_system_header_dir
1973 case "$host","$target" in
1974 # Darwin crosses can use the host system's libraries and headers,
1975 # because of the fat library support. Of course, it must be the
1976 # same version of Darwin on both sides. Allow the user to
1977 # just say --target=foo-darwin without a version number to mean
1978 # "the version on this system".
1979 *-*-darwin*,*-*-darwin*)
1980 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1981 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1982 if test $hostos = $targetos -o $targetos = darwin ; then
1984 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1989 i?86-*-*,x86_64-*-* \
1990 | powerpc*-*-*,powerpc64*-*-*)
1991 CROSS="$CROSS -DNATIVE_CROSS" ;;
1996 if test "x$with_headers" = x; then
2003 elif test "x$TARGET_SYSTEM_ROOT" != x; then
2004 SYSTEM_HEADER_DIR=$build_system_header_dir
2007 # If this is a cross-compiler that does not
2008 # have its own set of headers then define
2011 # If this is using newlib, without having the headers available now,
2012 # then define inhibit_libc in LIBGCC2_CFLAGS.
2013 # This prevents libgcc2 from containing any code which requires libc
2015 : ${inhibit_libc=false}
2016 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
2017 test x$with_newlib = xyes ; } &&
2018 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
2021 AC_SUBST(inhibit_libc)
2023 # When building gcc with a cross-compiler, we need to adjust things so
2024 # that the generator programs are still built with the native compiler.
2025 # Also, we cannot run fixincludes.
2027 # These are the normal (build=host) settings:
2028 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
2029 CXX_FOR_BUILD='$(CXX)' AC_SUBST(CXX_FOR_BUILD)
2030 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
2031 BUILD_CXXFLAGS='$(ALL_CXXFLAGS)' AC_SUBST(BUILD_CXXFLAGS)
2032 BUILD_LDFLAGS='$(LDFLAGS)' AC_SUBST(BUILD_LDFLAGS)
2033 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
2035 # And these apply if build != host, or we are generating coverage data
2036 if test x$build != x$host || test "x$coverage_flags" != x
2038 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
2039 BUILD_CXXFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CXXFLAGS_FOR_BUILD)'
2040 BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
2043 # Expand extra_headers to include complete path.
2044 # This substitutes for lots of t-* files.
2046 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
2047 for file in ${extra_headers} ; do
2048 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
2051 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
2052 if test x"$use_gcc_tgmath" = xyes
2053 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
2056 # Define collect2 in Makefile.
2057 case $host_can_use_collect2 in
2059 *) collect2='collect2$(exeext)' ;;
2061 AC_SUBST([collect2])
2063 # Add a definition of USE_COLLECT2 if system wants one.
2064 case $use_collect2 in
2065 no) use_collect2= ;;
2068 host_xm_defines="${host_xm_defines} USE_COLLECT2"
2069 xm_defines="${xm_defines} USE_COLLECT2"
2070 case $host_can_use_collect2 in
2072 AC_MSG_ERROR([collect2 is required but cannot be built on this system])
2078 AC_DEFINE_UNQUOTED(LTOPLUGINSONAME,"${host_lto_plugin_soname}",
2079 [Define to the name of the LTO plugin DSO that must be
2080 passed to the linker's -plugin=LIB option.])
2082 # ---------------------------
2083 # Assembler & linker features
2084 # ---------------------------
2086 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
2087 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
2088 # However when ld-new is first executed from the build tree, libtool will
2089 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
2090 # to the build tree. While doing this we need to use the previous-stage
2091 # linker, or we have an infinite loop. The presence of a shell script as
2092 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
2093 # the gcc/collect-ld script. So we need to know how libtool works, or
2094 # exec-tool will fail.
2096 m4_defun([_LT_CONFIG_COMMANDS], [])
2099 AC_SUBST(enable_fast_install)
2101 # Identify the assembler which will work hand-in-glove with the newly
2102 # built GCC, so that we can examine its features. This is the assembler
2103 # which will be driven by the driver program.
2105 # If build != host, and we aren't building gas in-tree, we identify a
2106 # build->target assembler and hope that it will have the same features
2107 # as the host->target assembler we'll be using.
2108 gcc_cv_gas_major_version=
2109 gcc_cv_gas_minor_version=
2110 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
2112 m4_pattern_allow([AS_FOR_TARGET])dnl
2113 AS_VAR_SET_IF(gcc_cv_as,, [
2114 if test -x "$DEFAULT_ASSEMBLER"; then
2115 gcc_cv_as="$DEFAULT_ASSEMBLER"
2116 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
2117 && test -f ../gas/Makefile \
2118 && test x$build = x$host; then
2119 gcc_cv_as=../gas/as-new$build_exeext
2120 elif test -x as$build_exeext; then
2121 # Build using assembler in the current directory.
2122 gcc_cv_as=./as$build_exeext
2123 elif ( set dummy $AS_FOR_TARGET; test -x $[2] ); then
2124 gcc_cv_as="$AS_FOR_TARGET"
2126 AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
2129 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
2130 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
2131 case "$ORIGINAL_AS_FOR_TARGET" in
2132 ./as | ./as$build_exeext) ;;
2133 *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
2136 AC_MSG_CHECKING(what assembler to use)
2137 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
2138 # Single tree build which includes gas. We want to prefer it
2139 # over whatever linker top-level may have detected, since
2140 # we'll use what we're building after installation anyway.
2141 AC_MSG_RESULT(newly built gas)
2143 _gcc_COMPUTE_GAS_VERSION
2144 in_tree_gas_is_elf=no
2145 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
2146 || (grep 'obj_format = multi' ../gas/Makefile \
2147 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
2149 in_tree_gas_is_elf=yes
2152 AC_MSG_RESULT($gcc_cv_as)
2158 [[ --enable-ld[=ARG] build ld [ARG={default,yes,no}]]],
2159 [case "${enableval}" in
2166 [[ --enable-gold[=ARG] build gold [ARG={default,yes,no}]]],
2167 [case "${enableval}" in
2169 install_gold_as_default=yes
2172 if test x${default_ld} != x; then
2173 install_gold_as_default=yes
2179 AC_MSG_ERROR([invalid --enable-gold argument])
2182 [install_gold_as_default=no])
2184 # Identify the linker which will work hand-in-glove with the newly
2185 # built GCC, so that we can examine its features. This is the linker
2186 # which will be driven by the driver program.
2188 # If build != host, and we aren't building gas in-tree, we identify a
2189 # build->target linker and hope that it will have the same features
2190 # as the host->target linker we'll be using.
2191 gcc_cv_gld_major_version=
2192 gcc_cv_gld_minor_version=
2193 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
2194 gcc_cv_ld_gold_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gold
2195 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
2197 AS_VAR_SET_IF(gcc_cv_ld,, [
2198 if test -x "$DEFAULT_LINKER"; then
2199 gcc_cv_ld="$DEFAULT_LINKER"
2200 elif test $install_gold_as_default = yes \
2201 && test -f $gcc_cv_ld_gold_srcdir/configure.ac \
2202 && test -f ../gold/Makefile \
2203 && test x$build = x$host; then
2204 gcc_cv_ld=../gold/ld-new$build_exeext
2205 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
2206 && test -f ../ld/Makefile \
2207 && test x$build = x$host; then
2208 gcc_cv_ld=../ld/ld-new$build_exeext
2209 elif test -x collect-ld$build_exeext; then
2210 # Build using linker in the current directory.
2211 gcc_cv_ld=./collect-ld$build_exeext
2212 elif ( set dummy $LD_FOR_TARGET; test -x $[2] ); then
2213 gcc_cv_ld="$LD_FOR_TARGET"
2215 AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
2218 ORIGINAL_PLUGIN_LD_FOR_TARGET=$gcc_cv_ld
2219 PLUGIN_LD_SUFFIX=`basename $gcc_cv_ld | sed -e "s,$target_alias-,,"`
2220 # if the PLUGIN_LD is set ld-new, just have it as ld
2221 # as that is the installed named.
2222 if test x$PLUGIN_LD_SUFFIX = xld-new \
2223 || test x$PLUGIN_LD_SUFFIX = xcollect-ld ; then
2226 AC_ARG_WITH(plugin-ld,
2227 [AS_HELP_STRING([[--with-plugin-ld=[ARG]]], [specify the plugin linker])],
2228 [if test x"$withval" != x; then
2229 ORIGINAL_PLUGIN_LD_FOR_TARGET="$withval"
2230 PLUGIN_LD_SUFFIX=`echo $withval | sed -e "s,$target_alias-,,"`
2232 AC_SUBST(ORIGINAL_PLUGIN_LD_FOR_TARGET)
2233 AC_DEFINE_UNQUOTED(PLUGIN_LD_SUFFIX, "$PLUGIN_LD_SUFFIX", [Specify plugin linker])
2235 # Check to see if we are using gold instead of ld
2236 AC_MSG_CHECKING(whether we are using gold)
2238 if test x$gcc_cv_ld != x; then
2239 if $gcc_cv_ld --version 2>/dev/null | sed 1q \
2240 | grep "GNU gold" > /dev/null; then
2244 AC_MSG_RESULT($ld_is_gold)
2246 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
2247 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
2248 case "$ORIGINAL_LD_FOR_TARGET" in
2249 ./collect-ld | ./collect-ld$build_exeext) ;;
2250 *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
2253 AC_MSG_CHECKING(what linker to use)
2254 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext \
2255 || test "$gcc_cv_ld" = ../gold/ld-new$build_exeext; then
2256 # Single tree build which includes ld. We want to prefer it
2257 # over whatever linker top-level may have detected, since
2258 # we'll use what we're building after installation anyway.
2259 AC_MSG_RESULT(newly built ld)
2261 in_tree_ld_is_elf=no
2262 if (grep 'EMUL = .*elf' ../ld/Makefile \
2263 || grep 'EMUL = .*linux' ../ld/Makefile \
2264 || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
2265 in_tree_ld_is_elf=yes
2266 elif test "$ld_is_gold" = yes; then
2267 in_tree_ld_is_elf=yes
2269 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
2272 gcc_cv_gld_version=`sed -n -e 's/^[ ]*VERSION=[^0-9A-Za-z_]*\([0-9]*\.[0-9]*.*\)/VERSION=\1/p' < $f`
2273 if test x$gcc_cv_gld_version != x; then
2277 case $gcc_cv_gld_version in
2280 *) AC_MSG_ERROR([[cannot find version of in-tree linker]]) ;;
2283 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
2284 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
2286 ORIGINAL_LD_BFD_FOR_TARGET=../ld/ld-new$build_exeext
2287 ORIGINAL_LD_GOLD_FOR_TARGET=../gold/ld-new$build_exeext
2289 AC_MSG_RESULT($gcc_cv_ld)
2291 gcc_cvs_ld_program=`dirname $gcc_cv_ld`/`basename $gcc_cv_ld $host_exeext`
2292 ORIGINAL_LD_BFD_FOR_TARGET=${gcc_cvs_ld_program}.bfd$host_exeext
2293 ORIGINAL_LD_GOLD_FOR_TARGET=${gcc_cvs_ld_program}.gold$host_exeext
2296 AC_SUBST(ORIGINAL_LD_BFD_FOR_TARGET)
2297 AC_SUBST(ORIGINAL_LD_GOLD_FOR_TARGET)
2299 # Figure out what nm we will be using.
2300 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
2301 AS_VAR_SET_IF(gcc_cv_nm,, [
2302 if test -f $gcc_cv_binutils_srcdir/configure.in \
2303 && test -f ../binutils/Makefile \
2304 && test x$build = x$host; then
2305 gcc_cv_nm=../binutils/nm-new$build_exeext
2306 elif test -x nm$build_exeext; then
2307 gcc_cv_nm=./nm$build_exeext
2308 elif ( set dummy $NM_FOR_TARGET; test -x $[2] ); then
2309 gcc_cv_nm="$NM_FOR_TARGET"
2311 AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
2314 AC_MSG_CHECKING(what nm to use)
2315 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
2316 # Single tree build which includes binutils.
2317 AC_MSG_RESULT(newly built nm)
2320 AC_MSG_RESULT($gcc_cv_nm)
2324 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
2325 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
2326 case "$ORIGINAL_NM_FOR_TARGET" in
2327 ./nm | ./nm$build_exeext) ;;
2328 *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
2332 # Figure out what objdump we will be using.
2333 AS_VAR_SET_IF(gcc_cv_objdump,, [
2334 if test -f $gcc_cv_binutils_srcdir/configure.in \
2335 && test -f ../binutils/Makefile \
2336 && test x$build = x$host; then
2337 # Single tree build which includes binutils.
2338 gcc_cv_objdump=../binutils/objdump$build_exeext
2339 elif test -x objdump$build_exeext; then
2340 gcc_cv_objdump=./objdump$build_exeext
2341 elif ( set dummy $OBJDUMP_FOR_TARGET; test -x $[2] ); then
2342 gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
2344 AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
2347 AC_MSG_CHECKING(what objdump to use)
2348 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
2349 # Single tree build which includes binutils.
2350 AC_MSG_RESULT(newly built objdump)
2351 elif test x$gcc_cv_objdump = x; then
2352 AC_MSG_RESULT(not found)
2354 AC_MSG_RESULT($gcc_cv_objdump)
2357 # Figure out what readelf we will be using.
2358 AS_VAR_SET_IF(gcc_cv_readelf,, [
2359 if test -f $gcc_cv_binutils_srcdir/configure.in \
2360 && test -f ../binutils/Makefile \
2361 && test x$build = x$host; then
2362 # Single tree build which includes binutils.
2363 gcc_cv_readelf=../binutils/readelf$build_exeext
2364 elif test -x readelf$build_exeext; then
2365 gcc_cv_readelf=./readelf$build_exeext
2367 AC_PATH_PROG(gcc_cv_readelf, readelf)
2370 AC_MSG_CHECKING(what readelf to use)
2371 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
2372 # Single tree build which includes binutils.
2373 AC_MSG_RESULT(newly built readelf)
2374 elif test x$gcc_cv_readelf = x; then
2375 AC_MSG_RESULT(not found)
2377 AC_MSG_RESULT($gcc_cv_readelf)
2380 # Figure out what assembler alignment features are present.
2381 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
2385 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2386 [Define if your assembler supports .balign and .p2align.])])
2388 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2391 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2392 [Define if your assembler supports specifying the maximum number
2393 of bytes to skip when using the GAS .p2align command.])])
2395 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2398 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2399 [Define if your assembler supports .literal16.])])
2401 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2403 [conftest_label1: .word 0
2405 conftest_label2: .word 0
2407 [if test x$gcc_cv_nm != x; then
2408 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2409 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2410 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2412 else gcc_cv_as_subsection_m1=yes
2414 rm -f conftest.nm1 conftest.nm2
2416 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2417 [Define if your assembler supports .subsection and .subsection -1 starts
2418 emitting at the beginning of your section.])])
2420 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2423 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2425 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2427 [ .weakref foobar, barfnot],,
2428 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2430 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2433 .NSUBSPA $CODE$,COMDAT],,
2434 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2436 # .hidden needs to be supported in both the assembler and the linker,
2437 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2438 # This is irritatingly difficult to feature test for; we have to check the
2439 # date string after the version number. If we've got an in-tree
2440 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2442 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2443 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2447 # Solaris 9/x86 as incorrectly emits an alias for a hidden symbol with
2448 # STV_HIDDEN, so disable .hidden support if so.
2450 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2451 if test x$gcc_cv_as != x && test x$gcc_cv_objdump != x; then
2452 cat > conftest.s <<EOF
2459 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1 \
2460 && $gcc_cv_objdump -t conftest.o 2>/dev/null | \
2461 grep '\.hidden default' > /dev/null; then
2464 gcc_cv_as_hidden=yes
2467 # Assume bug is present if objdump is missing.
2472 gcc_cv_as_hidden=yes
2477 # Darwin as has some visibility support, though with a different syntax.
2478 gcc_cv_as_hidden=yes
2482 # gnu_indirect_function type is an extension proposed at
2483 # http://groups.google/com/group/generic-abi/files. It allows dynamic runtime
2484 # selection of function implementation
2485 AC_ARG_ENABLE(gnu-indirect-function,
2486 [AS_HELP_STRING([--enable-gnu-indirect-function],
2487 [enable the use of the @gnu_indirect_function to glibc systems])],
2488 [case $enable_gnu_indirect_function in
2490 *) AC_MSG_ERROR(['$enable_gnu_indirect_function' is an invalid value for --enable-gnu-indirect-function.
2491 Valid choices are 'yes' and 'no'.]) ;;
2493 [enable_gnu_indirect_function="$default_gnu_indirect_function"])
2495 gif=`if test x$enable_gnu_indirect_function = xyes; then echo 1; else echo 0; fi`
2496 AC_DEFINE_UNQUOTED(HAVE_GNU_INDIRECT_FUNCTION, $gif,
2497 [Define if your system supports gnu indirect functions.])
2501 if test $in_tree_ld != yes ; then
2502 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2503 if echo "$ld_ver" | grep GNU > /dev/null; then
2504 if test x"$ld_is_gold" = xyes; then
2505 # GNU gold --version looks like this:
2507 # GNU gold (GNU Binutils 2.21.51.20110225) 1.11
2509 # We extract the binutils version which is more familiar and specific
2510 # than the gold version.
2511 ld_vers=`echo $ld_ver | sed -n \
2512 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
2514 # GNU ld --version looks like this:
2516 # GNU ld (GNU Binutils) 2.21.51.20110225
2517 ld_vers=`echo $ld_ver | sed -n \
2518 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2520 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'`
2521 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2522 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2523 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2527 # See acinclude.m4 (gcc_SUN_LD_VERSION) for the version number
2530 # Don't reuse gcc_gv_sun_ld_vers_* in case a linker other than
2531 # /usr/ccs/bin/ld has been configured.
2532 ld_ver=`$gcc_cv_ld -V 2>&1`
2533 if echo "$ld_ver" | grep 'Solaris Link Editors' > /dev/null; then
2534 ld_vers=`echo $ld_ver | sed -n \
2535 -e 's,^.*: 5\.[0-9][0-9]*-\([0-9]\.[0-9][0-9]*\).*$,\1,p'`
2536 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2537 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2545 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2546 [[if test $in_tree_ld = yes ; then
2548 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 \
2549 && test $in_tree_ld_is_elf = yes; then
2550 gcc_cv_ld_hidden=yes
2553 gcc_cv_ld_hidden=yes
2554 if test x"$ld_is_gold" = xyes; then
2556 elif echo "$ld_ver" | grep GNU > /dev/null; then
2558 mmix-knuth-mmixware)
2559 # The linker emits by default mmo, not ELF, so "no" is appropriate.
2563 if test 0"$ld_date" -lt 20020404; then
2564 if test -n "$ld_date"; then
2565 # If there was date string, but was earlier than 2002-04-04, fail
2567 elif test -z "$ld_vers"; then
2568 # If there was no date string nor ld version number, something is wrong
2571 test -z "$ld_vers_patch" && ld_vers_patch=0
2572 if test "$ld_vers_major" -lt 2; then
2574 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2575 gcc_cv_ld_hidden="no"
2576 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2584 # Darwin ld has some visibility support.
2585 gcc_cv_ld_hidden=yes
2587 hppa64*-*-hpux* | ia64*-*-hpux*)
2588 gcc_cv_ld_hidden=yes
2590 *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2591 # Support for .hidden in Sun ld appeared in Solaris 9 FCS, but
2592 # .symbolic was only added in Solaris 9 12/02.
2593 gcc_cv_ld_hidden=yes
2601 libgcc_visibility=no
2602 AC_SUBST(libgcc_visibility)
2603 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2604 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2605 libgcc_visibility=yes
2606 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2607 [Define if your assembler and linker support .hidden.])
2610 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2611 gcc_cv_ld_ro_rw_mix=unknown
2612 if test $in_tree_ld = yes ; then
2613 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 \
2614 && test $in_tree_ld_is_elf = yes; then
2615 gcc_cv_ld_ro_rw_mix=read-write
2617 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2618 echo '.section myfoosect, "a"' > conftest1.s
2619 echo '.section myfoosect, "aw"' > conftest2.s
2620 echo '.byte 1' >> conftest2.s
2621 echo '.section myfoosect, "a"' > conftest3.s
2622 echo '.byte 0' >> conftest3.s
2623 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2624 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2625 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2626 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2627 conftest2.o conftest3.o > /dev/null 2>&1; then
2628 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2629 | sed -e '/myfoosect/!d' -e N`
2630 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2631 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2632 gcc_cv_ld_ro_rw_mix=read-only
2634 gcc_cv_ld_ro_rw_mix=read-write
2639 rm -f conftest.* conftest[123].*
2642 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2643 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2644 [Define if your linker links a mix of read-only
2645 and read-write sections into a read-write section.])
2647 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2649 gcc_AC_INITFINI_ARRAY
2651 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2652 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2660 [[# GAS versions before 2.11 do not support uleb128,
2661 # despite appearing to.
2662 # ??? There exists an elf-specific test that will crash
2663 # the assembler. Perhaps it's better to figure out whether
2664 # arbitrary sections are supported and try the test.
2665 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2666 if echo "$as_ver" | grep GNU > /dev/null; then
2667 as_vers=`echo $as_ver | sed -n \
2668 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2669 as_major=`expr "$as_vers" : '\([0-9]*\)'`
2670 as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2671 if test $as_major -eq 2 && test $as_minor -lt 11
2673 else gcc_cv_as_leb128=yes
2676 [AC_DEFINE(HAVE_AS_LEB128, 1,
2677 [Define if your assembler supports .sleb128 and .uleb128.])])
2679 # Check if we have assembler support for unwind directives.
2680 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2687 .cfi_escape 1, 2, 3, 4, 5
2691 # If the linker used on Solaris (like Sun ld) isn't capable of merging
2692 # read-only and read-write sections, we need to make sure that the
2693 # assembler used emits read-write .eh_frame sections.
2694 if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2695 if test "x$gcc_cv_objdump" != x; then
2696 if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2697 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2698 gcc_cv_as_cfi_directive=no
2701 i?86-*-solaris2.1[[0-9]]* | x86_64-*-solaris2.1[[0-9]]*)
2702 # On Solaris/x86, make sure that GCC and gas agree on using
2703 # read-only .eh_frame sections for 64-bit.
2704 if $gcc_cv_as --64 -o conftest.o conftest.s > /dev/null 2>&1 && \
2705 $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2706 sed -e /.eh_frame/!d -e N | \
2707 grep READONLY > /dev/null; then
2708 gcc_cv_as_cfi_directive=yes
2710 gcc_cv_as_cfi_directive=no
2714 gcc_cv_as_cfi_directive=yes
2719 # no objdump, err on the side of caution
2720 gcc_cv_as_cfi_directive=no
2723 gcc_cv_as_cfi_directive=yes
2727 gcc_cv_as_cfi_directive=yes
2730 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_objdump != x; then
2731 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2735 .cfi_adjust_cfa_offset 64
2737 .cfi_adjust_cfa_offset 128
2740 if $gcc_cv_objdump -Wf conftest.o 2>/dev/null \
2741 | grep 'DW_CFA_advance_loc[24]:[ ][ ]*75040[ ]' >/dev/null; then
2742 gcc_cv_as_cfi_advance_working=yes
2746 # no objdump, err on the side of caution
2747 gcc_cv_as_cfi_advance_working=no
2749 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_DIRECTIVE)
2750 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2751 [`if test $gcc_cv_as_cfi_directive = yes \
2752 && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2753 [Define 0/1 if your assembler supports CFI directives.])
2755 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE)
2756 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2757 gcc_cv_as_cfi_personality_directive, ,,
2760 .cfi_personality 0, symbol
2762 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2763 [`if test $gcc_cv_as_cfi_personality_directive = yes;
2764 then echo 1; else echo 0; fi`],
2765 [Define 0/1 if your assembler supports .cfi_personality.])
2767 gcc_GAS_CHECK_FEATURE([cfi sections directive],
2768 gcc_cv_as_cfi_sections_directive, ,,
2770 .cfi_sections .debug_frame, .eh_frame
2774 win32 | pe | cygwin* | mingw32* | uwin*)
2775 # Need to check that we generated the correct relocation for the
2776 # .debug_frame section. This was fixed for binutils 2.21.
2777 gcc_cv_as_cfi_sections_directive=no
2778 if test "x$gcc_cv_objdump" != x; then
2779 if $gcc_cv_objdump -j .debug_frame -r conftest.o 2>/dev/null | \
2780 grep secrel > /dev/null; then
2781 gcc_cv_as_cfi_sections_directive=yes
2786 gcc_cv_as_cfi_sections_directive=yes
2789 GCC_TARGET_TEMPLATE(HAVE_GAS_CFI_SECTIONS_DIRECTIVE)
2790 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_SECTIONS_DIRECTIVE,
2791 [`if test $gcc_cv_as_cfi_sections_directive = yes;
2792 then echo 1; else echo 0; fi`],
2793 [Define 0/1 if your assembler supports .cfi_sections.])
2795 # GAS versions up to and including 2.11.0 may mis-optimize
2797 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2805 .section .eh_frame,"aw",@progbits
2807 .4byte .LECIE1-.LSCIE1
2821 .4byte .LEFDE1-.LASFDE1
2823 .4byte .LASFDE1-__FRAME_BEGIN__
2831 [ dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2832 cat > conftest.lit <<EOF
2833 0000 10000000 00000000 017a0001 781a0004 .........z..x...
2834 0010 01000000 12000000 18000000 00000000 ................
2835 0020 08000000 04080000 0044 .........D @&t@
2837 cat > conftest.big <<EOF
2838 0000 00000010 00000000 017a0001 781a0004 .........z..x...
2839 0010 00000001 00000012 00000018 00000000 ................
2840 0020 00000008 04000000 0844 .........D @&t@
2842 # If the assembler didn't choke, and we can objdump,
2843 # and we got the correct data, then succeed.
2844 # The text in the here-document typically retains its unix-style line
2845 # endings, while the output of objdump will use host line endings.
2846 # Therefore, use diff -b for the comparisons.
2847 if test x$gcc_cv_objdump != x \
2848 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2849 | tail -3 > conftest.got \
2850 && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2851 || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2853 gcc_cv_as_eh_frame=yes
2854 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2855 gcc_cv_as_eh_frame=buggy
2857 # Uh oh, what do we do now?
2858 gcc_cv_as_eh_frame=no
2861 if test $gcc_cv_as_eh_frame = buggy; then
2862 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2863 [Define if your assembler mis-optimizes .eh_frame data.])
2866 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2867 [elf,2,12,0], [--fatal-warnings],
2868 [.section .rodata.str, "aMS", @progbits, 1])
2869 if test $gcc_cv_as_shf_merge = no; then
2870 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2871 [elf,2,12,0], [--fatal-warnings],
2872 [.section .rodata.str, "aMS", %progbits, 1])
2874 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2875 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2876 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2878 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as)],
2879 gcc_cv_as_comdat_group,
2880 [elf,2,16,0], [--fatal-warnings],
2881 [.section .text,"axG",@progbits,.foo,comdat])
2882 if test $gcc_cv_as_comdat_group = yes; then
2883 gcc_cv_as_comdat_group_percent=no
2884 gcc_cv_as_comdat_group_group=no
2886 gcc_GAS_CHECK_FEATURE([COMDAT group support (GNU as, %type)],
2887 gcc_cv_as_comdat_group_percent,
2888 [elf,2,16,0], [--fatal-warnings],
2889 [.section .text,"axG",%progbits,.foo,comdat])
2890 if test $gcc_cv_as_comdat_group_percent = yes; then
2891 gcc_cv_as_comdat_group_group=no
2893 if test -z "${gcc_cv_as_comdat_group_group+set}"; then
2894 gcc_cv_as_comdat_group_group=no
2897 # Sun as uses a completely different syntax.
2902 .group foo,".text%foo",#comdat
2903 .section ".text%foo", #alloc,#execinstr,#progbits
2908 i?86-*-solaris2* | x86_64-*-solaris2.1[[0-9]]*)
2910 .group foo,.text%foo,#comdat
2911 .section .text%foo, "ax", @progbits
2917 gcc_GAS_CHECK_FEATURE([COMDAT group support (Sun as, .group)],
2918 gcc_cv_as_comdat_group_group,
2924 if test x"$ld_is_gold" = xyes; then
2926 elif test $in_tree_ld = yes ; then
2928 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 \
2929 && test $in_tree_ld_is_elf = yes; then
2932 elif echo "$ld_ver" | grep GNU > /dev/null; then
2934 if test 0"$ld_date" -lt 20050308; then
2935 if test -n "$ld_date"; then
2936 # If there was date string, but was earlier than 2005-03-08, fail
2938 elif test "$ld_vers_major" -lt 2; then
2940 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2947 *-*-solaris2.1[1-9]*)
2949 # Sun ld has COMDAT group support since Solaris 9, but it doesn't
2950 # interoperate with GNU as until Solaris 11 build 130, i.e. ld
2953 # If using Sun as for COMDAT group as emitted by GCC, one needs at
2954 # least ld version 1.2267.
2955 if test "$ld_vers_major" -gt 1; then
2957 elif test "x$gas_flag" = xyes && test "$ld_vers_minor" -ge 1688; then
2959 elif test "$ld_vers_minor" -ge 2267; then
2964 # Assume linkers other than GNU ld don't support COMDAT group.
2970 # Allow overriding the automatic COMDAT group tests above.
2971 AC_ARG_ENABLE(comdat,
2972 [AS_HELP_STRING([--enable-comdat], [enable COMDAT group support])],
2973 [comdat_group="$enable_comdat"])
2974 if test $comdat_group = no; then
2975 gcc_cv_as_comdat_group=no
2976 gcc_cv_as_comdat_group_percent=no
2977 gcc_cv_as_comdat_group_group=no
2979 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2980 [`if test $gcc_cv_as_comdat_group = yes \
2981 || test $gcc_cv_as_comdat_group_percent = yes \
2982 || test $gcc_cv_as_comdat_group_group = yes; then echo 1; else echo 0; fi`],
2983 [Define 0/1 if your assembler and linker support COMDAT groups.])
2985 gcc_GAS_CHECK_FEATURE([line table discriminator support],
2986 gcc_cv_as_discriminator,
2990 .loc 1 1 0 discriminator 1],,
2991 [AC_DEFINE(HAVE_GAS_DISCRIMINATOR, 1,
2992 [Define if your assembler supports the .loc discriminator sub-directive.])])
2994 # Thread-local storage - the check is heavily parameterized.
3003 .section ".tdata","awT",@progbits
3006 ldq $27,__tls_get_addr($29) !literal!1
3007 lda $16,foo($29) !tlsgd!1
3008 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
3009 ldq $27,__tls_get_addr($29) !literal!2
3010 lda $16,foo($29) !tlsldm!2
3011 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
3012 ldq $1,foo($29) !gotdtprel
3013 ldah $2,foo($29) !dtprelhi
3014 lda $3,foo($2) !dtprello
3015 lda $4,foo($29) !dtprel
3016 ldq $1,foo($29) !gottprel
3017 ldah $2,foo($29) !tprelhi
3018 lda $3,foo($2) !tprello
3019 lda $4,foo($29) !tprel'
3022 tls_as_opt=--fatal-warnings
3024 cris-*-*|crisv32-*-*)
3026 .section ".tdata","awT",@progbits
3033 tls_as_opt=--fatal-warnings
3037 .section ".tdata","awT",@progbits
3049 .section ".tdata","awT",@progbits
3053 addil LT%foo-$tls_gdidx$,gp
3054 ldo RT%foo-$tls_gdidx$(%r1),%arg0
3057 addil LT%foo-$tls_ldidx$,gp
3059 ldo RT%foo-$tls_ldidx$(%r1),%arg0
3060 addil LR%foo-$tls_dtpoff$,%ret0
3061 ldo RR%foo-$tls_dtpoff$(%r1),%t1
3063 addil LT%foo-$tls_ieoff$,gp
3064 ldw RT%foo-$tls_ieoff$(%r1),%t2
3067 addil LR%foo-$tls_leoff$,%t1
3068 ldo RR%foo-$tls_leoff$(%r1),%t2'
3071 tls_as_opt=--fatal-warnings
3075 .section ".tdata","awT",%progbits
3086 i[34567]86-*-* | x86_64-*-solaris2.1[0-9]*)
3088 i[34567]86-*-solaris2.*)
3090 tga_func=___tls_get_addr
3092 x86_64-*-solaris2.1[0-9]*)
3094 tga_func=__tls_get_addr
3100 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3102 .section .tdata,"awt",@progbits'
3107 AC_DEFINE(TLS_SECTION_ASM_FLAG, 't',
3108 [Define to the flag used to mark TLS sections if the default (`T') doesn't work.])
3112 .section ".tdata","awT",@progbits'
3116 tls_as_opt="--fatal-warnings"
3118 conftest_s="$conftest_s
3122 leal foo@tlsgd(,%ebx,1), %eax
3123 leal foo@tlsldm(%ebx), %eax
3124 leal foo@dtpoff(%eax), %edx
3125 movl foo@gottpoff(%ebx), %eax
3126 subl foo@gottpoff(%ebx), %eax
3127 addl foo@gotntpoff(%ebx), %eax
3128 movl foo@indntpoff, %eax
3129 movl \$foo@tpoff, %eax
3130 subl \$foo@tpoff, %eax
3131 leal foo@ntpoff(%ecx), %eax"
3135 .section ".tdata","awT",@progbits
3139 leaq foo@TLSGD(%rip), %rdi
3140 leaq foo@TLSLD(%rip), %rdi
3141 leaq foo@DTPOFF(%rax), %rdx
3142 movq foo@GOTTPOFF(%rip), %rax
3143 movq $foo@TPOFF, %rax'
3147 tls_as_opt=--fatal-warnings
3151 .section ".tdata","awT",@progbits
3154 addl r16 = @ltoff(@dtpmod(foo#)), gp
3155 addl r17 = @ltoff(@dtprel(foo#)), gp
3156 addl r18 = @ltoff(@tprel(foo#)), gp
3157 addl r19 = @dtprel(foo#), gp
3158 adds r21 = @dtprel(foo#), r13
3159 movl r23 = @dtprel(foo#)
3160 addl r20 = @tprel(foo#), gp
3161 adds r22 = @tprel(foo#), r13
3162 movl r24 = @tprel(foo#)'
3165 tls_as_opt=--fatal-warnings
3169 .section .tdata,"awT",@progbits
3173 addik r5,r20,x@TLSGD
3174 addik r5,r20,x@TLSLDM'
3177 tls_as_opt='--fatal-warnings'
3181 .section .tdata,"awT",@progbits
3185 addiu $4, $28, %tlsgd(x)
3186 addiu $4, $28, %tlsldm(x)
3187 lui $4, %dtprel_hi(x)
3188 addiu $4, $4, %dtprel_lo(x)
3189 lw $4, %gottprel(x)($28)
3190 lui $4, %tprel_hi(x)
3191 addiu $4, $4, %tprel_lo(x)'
3194 tls_as_opt='-32 --fatal-warnings'
3198 .section .tdata,"awT",@progbits
3203 move.l x@TLSGD(%a5),%a0
3204 move.l x@TLSLDM(%a5),%a0
3205 move.l x@TLSLDO(%a5),%a0
3206 move.l x@TLSIE(%a5),%a0
3207 move.l x@TLSLE(%a5),%a0'
3210 tls_as_opt='--fatal-warnings'
3214 .section ".tdata","awT",@progbits'
3217 tls_as_opt="--fatal-warnings"
3221 .section ".tdata","awT",%progbits
3225 add x0, x0, #:tlsgd_lo12:x
3230 tls_as_opt='--fatal-warnings'
3234 .extern __get_tpointer
3252 .section ".tdata","awT",@progbits
3260 addi 3,2,ld0@got@tlsgd
3266 addi 3,2,x1@got@tlsld
3272 addis 9,3,x2@dtprel@ha
3273 addi 9,9,x2@dtprel@l
3276 ld 9,x3@got@dtprel(2)
3282 tls_as_opt="-a64 --fatal-warnings"
3286 .section ".tdata","awT",@progbits
3294 addi 3,31,ld0@got@tlsgd
3296 addi 3,31,x1@got@tlsld
3299 addis 9,3,x2@dtprel@ha
3300 addi 9,9,x2@dtprel@l
3301 lwz 9,x3@got@tprel(31)
3304 addis 9,2,x2@tprel@ha
3305 addi 9,9,x2@tprel@l'
3308 tls_as_opt="-a32 --fatal-warnings"
3312 .section ".tdata","awT",@progbits
3321 l %r1,foo@GOTNTPOFF(%r12)
3322 l %r1,0(%r1):tls_load:foo
3323 bas %r14,0(%r1,%r13):tls_gdcall:foo
3324 bas %r14,0(%r1,%r13):tls_ldcall:foo'
3327 tls_as_opt="-m31 --fatal-warnings"
3331 .section ".tdata","awT",@progbits
3339 lg %r1,foo@GOTNTPOFF(%r12)
3340 larl %r1,foo@INDNTPOFF
3341 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
3342 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
3345 tls_as_opt="-m64 -Aesame --fatal-warnings"
3347 sh-*-* | sh[34]-*-*)
3349 .section ".tdata","awT",@progbits
3359 tls_as_opt=--fatal-warnings
3363 sparc*-sun-solaris2.*)
3365 tga_func=__tls_get_addr
3371 if test x$on_solaris = xyes && test x$gas_flag = xno; then
3373 .section ".tdata",#alloc,#write,#tls'
3378 .section ".tdata","awT",@progbits'
3381 tls_as_opt="-32 --fatal-warnings"
3383 conftest_s="$conftest_s
3386 sethi %tgd_hi22(foo), %o0
3387 add %o0, %tgd_lo10(foo), %o1
3388 add %l7, %o1, %o0, %tgd_add(foo)
3389 call __tls_get_addr, %tgd_call(foo)
3390 sethi %tldm_hi22(foo), %l1
3391 add %l1, %tldm_lo10(foo), %l2
3392 add %l7, %l2, %o0, %tldm_add(foo)
3393 call __tls_get_addr, %tldm_call(foo)
3394 sethi %tldo_hix22(foo), %l3
3395 xor %l3, %tldo_lox10(foo), %l4
3396 add %o0, %l4, %l5, %tldo_add(foo)
3397 sethi %tie_hi22(foo), %o3
3398 add %o3, %tie_lo10(foo), %o3
3399 ld [%l7 + %o3], %o2, %tie_ld(foo)
3400 add %g7, %o2, %o4, %tie_add(foo)
3401 sethi %tle_hix22(foo), %l1
3402 xor %l1, %tle_lox10(foo), %o5
3403 ld [%g7 + %o5], %o1"
3407 .section ".tdata","awT",@progbits
3410 addli r0, zero, tls_gd(foo)
3411 auli r0, zero, tls_gd_ha16(foo)
3412 addli r0, r0, tls_gd_lo16(foo)
3414 addli r0, zero, tls_ie(foo)
3415 auli r0, r0, tls_ie_ha16(foo)
3416 addli r0, r0, tls_ie_lo16(foo)'
3419 tls_as_opt="--fatal-warnings"
3423 .section ".tdata","awT",@progbits
3426 shl16insli r0, zero, hw0_last_tls_gd(foo)
3427 shl16insli r0, zero, hw1_last_tls_gd(foo)
3428 shl16insli r0, r0, hw0_tls_gd(foo)
3430 shl16insli r0, zero, hw1_last_tls_ie(foo)
3431 shl16insli r0, r0, hw0_tls_ie(foo)'
3434 tls_as_opt="--fatal-warnings"
3438 .section ".tdata","awT",@progbits
3441 movi a8, foo@TLSFUNC
3442 movi a10, foo@TLSARG
3443 callx8.tls a8, foo@TLSCALL'
3450 if test "x$enable_tls" = xno ; then
3451 : # TLS explicitly disabled.
3452 elif test "x$enable_tls" = xyes ; then
3453 set_have_as_tls=yes # TLS explicitly enabled.
3454 elif test -z "$tls_first_major"; then
3455 : # If we don't have a check, assume no support.
3457 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
3458 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
3459 [set_have_as_tls=yes])
3462 # TLS was introduced in the Solaris 9 FCS release. Support for GNU-style
3463 # TLS on x86 was only introduced in Solaris 9 4/04, replacing the earlier
3464 # Sun style that Sun ld and GCC don't support any longer.
3466 AC_MSG_CHECKING(linker and ld.so.1 TLS support)
3468 # Check ld and ld.so.1 TLS support.
3469 if echo "$ld_ver" | grep GNU > /dev/null; then
3470 # Assume all interesting versions of GNU ld have TLS support.
3471 # FIXME: still need ld.so.1 support, i.e. ld version checks below.
3475 # Solaris 9/x86 ld has GNU style TLS support since version 1.374.
3477 min_tls_ld_vers_minor=374
3479 # Solaris 9/SPARC and Solaris 10+ ld have TLS support since FCS.
3480 sparc*-*-solaris2.9 | *-*-solaris2.1[[0-9]]*)
3481 min_tls_ld_vers_minor=343
3484 if test "$ld_vers_major" -gt 1 || \
3485 test "$ld_vers_minor" -ge "$min_tls_ld_vers_minor"; then
3491 AC_MSG_RESULT($ld_tls_support)
3494 save_LDFLAGS="$LDFLAGS"
3498 AC_MSG_CHECKING(library containing $tga_func)
3499 # Before Solaris 10, __tls_get_addr (SPARC/x64) resp. ___tls_get_addr
3500 # (32-bit x86) only lived in libthread, so check for that. Keep
3501 # set_have_as_tls if found, disable if not.
3502 AC_SEARCH_LIBS([$tga_func], [thread],, [set_have_as_tls=no])
3504 # Clear LIBS if we cannot support TLS.
3505 if test $set_have_as_tls = no; then
3508 # Always define LIB_TLS_SPEC, even without TLS support.
3509 AC_DEFINE_UNQUOTED(LIB_TLS_SPEC, "$LIBS",
3510 [Define to the library containing __tls_get_addr/___tls_get_addr.])
3511 AC_MSG_RESULT($LIBS)
3514 LDFLAGS="$save_LDFLAGS"
3517 if test $set_have_as_tls = yes ; then
3518 AC_DEFINE(HAVE_AS_TLS, 1,
3519 [Define if your assembler and linker support thread-local storage.])
3522 # Target-specific assembler checks.
3524 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
3525 gcc_cv_ld_static_dynamic=no
3526 gcc_cv_ld_static_option='-Bstatic'
3527 gcc_cv_ld_dynamic_option='-Bdynamic'
3528 if test $in_tree_ld = yes ; then
3529 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
3530 gcc_cv_ld_static_dynamic=yes
3532 elif test x$gcc_cv_ld != x; then
3533 # Check if linker supports -Bstatic/-Bdynamic option
3534 if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
3535 && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
3536 gcc_cv_ld_static_dynamic=yes
3539 # AIX ld uses -b flags
3540 *-*-aix4.[[23]]* | *-*-aix[[5-9]]*)
3541 gcc_cv_ld_static_dynamic=yes
3542 gcc_cv_ld_static_option="-bstatic"
3543 gcc_cv_ld_dynamic_option="-bdynamic"
3545 # HP-UX ld uses -a flags to select between shared and archive.
3547 if test x"$gnu_ld" = xno; then
3548 gcc_cv_ld_static_dynamic=yes
3549 gcc_cv_ld_static_option="-aarchive_shared"
3550 gcc_cv_ld_dynamic_option="-adefault"
3553 # Solaris 2 ld always supports -Bstatic/-Bdynamic.
3555 gcc_cv_ld_static_dynamic=yes
3560 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
3561 AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
3562 [Define if your linker supports -Bstatic/-Bdynamic or equivalent options.])
3563 AC_DEFINE_UNQUOTED(LD_STATIC_OPTION, "$gcc_cv_ld_static_option",
3564 [Define to the linker option to disable use of shared objects.])
3565 AC_DEFINE_UNQUOTED(LD_DYNAMIC_OPTION, "$gcc_cv_ld_dynamic_option",
3566 [Define to the linker option to enable use of shared objects.])
3568 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
3570 if test x"$demangler_in_ld" = xyes; then
3571 AC_MSG_CHECKING(linker --demangle support)
3572 gcc_cv_ld_demangle=no
3573 if test $in_tree_ld = yes; then
3574 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 \
3575 gcc_cv_ld_demangle=yes
3577 elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
3578 # Check if the GNU linker supports --demangle option
3579 if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
3580 gcc_cv_ld_demangle=yes
3583 if test x"$gcc_cv_ld_demangle" = xyes; then
3584 AC_DEFINE(HAVE_LD_DEMANGLE, 1,
3585 [Define if your linker supports --demangle option.])
3587 AC_MSG_RESULT($gcc_cv_ld_demangle)
3590 AC_MSG_CHECKING(linker plugin support)
3592 if test -f liblto_plugin.la; then
3593 save_ld_ver="$ld_ver"
3594 save_ld_vers_major="$ld_vers_major"
3595 save_ld_vers_minor="$ld_vers_minor"
3596 save_ld_is_gold="$ld_is_gold"
3600 if test $in_tree_ld = yes -a x"$ORIGINAL_PLUGIN_LD_FOR_TARGET" = x"$gcc_cv_ld"; then
3602 # FIXME: ld_is_gold?
3603 ld_vers_major="$gcc_cv_gld_major_version"
3604 ld_vers_minor="$gcc_cv_gld_minor_version"
3606 # Determine plugin linker version.
3607 # FIXME: Partial duplicate from above, generalize.
3609 ld_ver=`$ORIGINAL_PLUGIN_LD_FOR_TARGET --version 2>/dev/null | sed 1q`
3610 if echo "$ld_ver" | grep GNU > /dev/null; then
3611 if echo "$ld_ver" | grep "GNU gold" > /dev/null; then
3613 ld_vers=`echo $ld_ver | sed -n \
3614 -e 's,^[^)]*[ ]\([0-9][0-9]*\.[0-9][0-9]*[^)]*\)) .*$,\1,p'`
3616 ld_vers=`echo $ld_ver | sed -n \
3617 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
3619 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
3620 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
3625 # Determine plugin support.
3626 if echo "$ld_ver" | grep GNU > /dev/null; then
3627 # Require GNU ld or gold 2.21+ for plugin support by default.
3628 if test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -ge 21; then
3630 # Allow -fuse-linker-plugin to enable plugin support in GNU gold 2.20.
3631 elif test "$ld_is_gold" = yes -a "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 20; then
3636 ld_ver="$save_ld_ver"
3637 ld_vers_major="$save_ld_vers_major"
3638 ld_vers_minor="$save_ld_vers_minor"
3639 ld_is_gold="$save_ld_is_gold"
3641 AC_DEFINE_UNQUOTED(HAVE_LTO_PLUGIN, $gcc_cv_lto_plugin,
3642 [Define to the level of your linker's plugin support.])
3643 AC_MSG_RESULT($gcc_cv_lto_plugin)
3647 gcc_GAS_CHECK_FEATURE([-mabi option], gcc_cv_as_aarch64_mabi,,
3648 [-mabi=lp64], [.text],,,)
3649 if test x$gcc_cv_as_aarch64_mabi = xyes; then
3650 AC_DEFINE(HAVE_AS_MABI_OPTION, 1,
3651 [Define if your assembler supports the -mabi option.])
3653 if test x$with_abi = xilp32; then
3654 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3655 Upgrade the Assembler.])
3657 if test x"$with_multilib_list" = xdefault; then
3658 TM_MULTILIB_CONFIG=lp64
3660 aarch64_multilibs=`echo $with_multilib_list | sed -e 's/,/ /g'`
3661 for aarch64_multilib in ${aarch64_multilibs}; do
3662 case ${aarch64_multilib} in
3664 AC_MSG_ERROR([Assembler does not support -mabi=ilp32.\
3665 Upgrade the Assembler.])
3675 # All TARGET_ABI_OSF targets.
3676 alpha*-*-linux* | alpha*-*-*bsd*)
3677 gcc_GAS_CHECK_FEATURE([explicit relocation support],
3678 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
3681 extbl $3, $2, $3 !lituse_bytoff!1
3682 ldq $2, a($29) !literal!1
3683 ldq $4, b($29) !literal!2
3684 ldq_u $3, 0($2) !lituse_base!1
3685 ldq $27, f($29) !literal!5
3686 jsr $26, ($27), f !lituse_jsr!5
3687 ldah $29, 0($26) !gpdisp!3
3688 lda $0, c($29) !gprel
3689 ldah $1, d($29) !gprelhigh
3690 lda $1, d($1) !gprellow
3691 lda $29, 0($29) !gpdisp!3],,
3692 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
3693 [Define if your assembler supports explicit relocations.])])
3694 gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
3695 gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
3698 ldq $27, a($29) !literal!1
3699 jsr $26, ($27), a !lituse_jsrdirect!1],,
3700 [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
3701 [Define if your assembler supports the lituse_jsrdirect relocation.])])
3705 gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
3706 gcc_cv_as_cris_no_mul_bug,[2,15,91],
3707 [-no-mul-bug-abort], [.text],,
3708 [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
3709 [Define if your assembler supports the -no-mul-bug-abort option.])])
3713 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
3714 [.register %g2, #scratch],,
3715 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
3716 [Define if your assembler supports .register.])])
3718 gcc_GAS_CHECK_FEATURE([@%:@nobits], gcc_cv_as_sparc_nobits,,,
3719 [.section "nobits",#alloc,#write,#nobits
3720 .section "progbits",#alloc,#write,#progbits])
3721 AC_DEFINE_UNQUOTED(HAVE_AS_SPARC_NOBITS,
3722 [`if test $gcc_cv_as_sparc_nobits = yes; then echo 1; else echo 0; fi`],
3723 [Define to 1 if your assembler supports #nobits, 0 otherwise.])
3725 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
3727 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
3728 [Define if your assembler supports -relax option.])])
3730 gcc_GAS_CHECK_FEATURE([GOTDATA_OP relocs],
3731 gcc_cv_as_sparc_gotdata_op,,
3738 sethi %gdop_hix22(foo), %g1
3739 xor %g1, %gdop_lox10(foo), %g1
3740 ld [[%l7 + %g1]], %g2, %gdop(foo)],
3741 [if test x$gcc_cv_ld != x \
3742 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3743 if test x$gcc_cv_objdump != x; then
3744 if $gcc_cv_objdump -s -j .text conftest 2> /dev/null \
3745 | grep ' 03000004 82186004 c405c001'> /dev/null 2>&1; then
3746 gcc_cv_as_sparc_gotdata_op=no
3748 gcc_cv_as_sparc_gotdata_op=yes
3753 [AC_DEFINE(HAVE_AS_SPARC_GOTDATA_OP, 1,
3754 [Define if your assembler and linker support GOTDATA_OP relocs.])])
3756 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
3757 gcc_cv_as_sparc_ua_pcrel,,
3765 .uaword %r_disp32(foo)],
3766 [if test x$gcc_cv_ld != x \
3767 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
3768 gcc_cv_as_sparc_ua_pcrel=yes
3771 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
3772 [Define if your assembler and linker support unaligned PC relative relocs.])
3774 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
3775 gcc_cv_as_sparc_ua_pcrel_hidden,,
3780 .uaword %r_disp32(foo)
3781 .byte 0x32, 0x33, 0x34
3786 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
3787 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
3788 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
3789 | grep ' 31000000 07323334' > /dev/null 2>&1; then
3790 if $gcc_cv_objdump -R conftest 2> /dev/null \
3791 | grep 'DISP32' > /dev/null 2>&1; then
3794 gcc_cv_as_sparc_ua_pcrel_hidden=yes
3798 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
3799 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
3800 ]) # unaligned pcrel relocs
3802 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
3803 gcc_cv_as_sparc_offsetable_lo10,,
3806 or %g1, %lo(ab) + 12, %g1
3807 or %g1, %lo(ab + 12), %g1],
3808 [if test x$gcc_cv_objdump != x \
3809 && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
3810 | grep ' 82106000 82106000' > /dev/null 2>&1; then
3811 gcc_cv_as_sparc_offsetable_lo10=yes
3813 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
3814 [Define if your assembler supports offsetable %lo().])])
3816 gcc_GAS_CHECK_FEATURE([FMAF, HPC, and VIS 3.0 instructions],
3817 gcc_cv_as_sparc_fmaf,,
3820 .register %g2, #scratch
3821 .register %g3, #scratch
3823 fmaddd %f0, %f2, %f4, %f6
3824 addxccc %g1, %g2, %g3
3825 fsrl32 %f2, %f4, %f8
3826 fnaddd %f10, %f12, %f14],,
3827 [AC_DEFINE(HAVE_AS_FMAF_HPC_VIS3, 1,
3828 [Define if your assembler supports FMAF, HPC, and VIS 3.0 instructions.])])
3830 gcc_GAS_CHECK_FEATURE([SPARC4 instructions],
3831 gcc_cv_as_sparc_sparc4,,
3834 .register %g2, #scratch
3835 .register %g3, #scratch
3838 1: cwbneg %g2, %g3, 1f
3841 aes_kexpand0 %f4, %f6, %f8
3842 des_round %f38, %f40, %f42, %f44
3843 camellia_f %f54, %f56, %f58, %f60
3844 kasumi_fi_xor %f46, %f48, %f50, %f52],,
3845 [AC_DEFINE(HAVE_AS_SPARC4, 1,
3846 [Define if your assembler supports SPARC4 instructions.])])
3848 gcc_GAS_CHECK_FEATURE([LEON instructions],
3849 gcc_cv_as_sparc_leon,,
3852 .register %g2, #scratch
3853 .register %g3, #scratch
3857 cas [[%g2]], %g3, %g1],,
3858 [AC_DEFINE(HAVE_AS_LEON, 1,
3859 [Define if your assembler supports LEON instructions.])])
3863 i[34567]86-*-* | x86_64-*-*)
3867 # Full C++ conformance when using a shared libstdc++-v3 requires some
3868 # support from the Cygwin DLL, which in more recent versions exports
3869 # wrappers to aid in interposing and redirecting operators new, delete,
3870 # etc., as per n2800 #17.6.4.6 [replacement.functions]. Check if we
3871 # are configuring for a version of Cygwin that exports the wrappers.
3872 if test x$host = x$target && test x$host_cpu = xi686; then
3873 AC_CHECK_FUNC([__wrap__Znaj],[gcc_ac_cygwin_dll_wrappers=yes],[gcc_ac_cygwin_dll_wrappers=no])
3875 # Can't check presence of libc functions during cross-compile, so
3876 # we just have to assume we're building for an up-to-date target.
3877 gcc_ac_cygwin_dll_wrappers=yes
3879 AC_DEFINE_UNQUOTED(USE_CYGWIN_LIBSTDCXX_WRAPPERS,
3880 [`if test $gcc_ac_cygwin_dll_wrappers = yes; then echo 1; else echo 0; fi`],
3881 [Define if you want to generate code by default that assumes that the
3882 Cygwin DLL exports wrappers to support libstdc++ function replacement.])
3885 cygwin* | pe | mingw32* | interix*)
3886 # Recent binutils allows the three-operand form of ".comm" on PE. This
3887 # definition is used unconditionally to initialise the default state of
3888 # the target option variable that governs usage of the feature.
3889 gcc_GAS_CHECK_FEATURE([.comm with alignment], gcc_cv_as_comm_has_align,
3890 [2,19,52],,[.comm foo,1,32])
3891 AC_DEFINE_UNQUOTED(HAVE_GAS_ALIGNED_COMM,
3892 [`if test $gcc_cv_as_comm_has_align = yes; then echo 1; else echo 0; fi`],
3893 [Define if your assembler supports specifying the alignment
3894 of objects allocated using the GAS .comm command.])
3895 # Used for DWARF 2 in PE
3896 gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
3897 gcc_cv_as_ix86_pe_secrel32,
3903 [if test x$gcc_cv_ld != x \
3904 && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
3905 gcc_cv_as_ix86_pe_secrel32=yes
3908 [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
3909 [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
3910 # Test if the assembler supports the extended form of the .section
3911 # directive that specifies section alignment. LTO support uses this,
3912 # but normally only after installation, so we warn but don't fail the
3913 # configure if LTO is enabled but the assembler does not support it.
3914 gcc_GAS_CHECK_FEATURE([.section with alignment], gcc_cv_as_section_has_align,
3915 [2,20,1],-fatal-warnings,[.section lto_test,"dr0"])
3916 if test x$gcc_cv_as_section_has_align != xyes; then
3917 case ",$enable_languages," in
3919 AC_MSG_WARN([LTO for $target requires binutils >= 2.20.1, but version found appears insufficient; LTO will not work until binutils is upgraded.])
3923 # Test if the assembler supports the section flag 'e' for specifying
3924 # an excluded section.
3925 gcc_GAS_CHECK_FEATURE([.section with e], gcc_cv_as_section_has_e,
3929 AC_DEFINE_UNQUOTED(HAVE_GAS_SECTION_EXCLUDE,
3930 [`if test $gcc_cv_as_section_has_e = yes; then echo 1; else echo 0; fi`],
3931 [Define if your assembler supports specifying the section flag e.])
3935 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
3936 gcc_cv_as_ix86_filds,,,
3937 [filds mem; fists mem],,
3938 [AC_DEFINE(HAVE_AS_IX86_FILDS, 1,
3939 [Define if your assembler uses filds and fists mnemonics.])])
3941 gcc_GAS_CHECK_FEATURE([fildq and fistpq mnemonics],
3942 gcc_cv_as_ix86_fildq,,,
3943 [fildq mem; fistpq mem],,
3944 [AC_DEFINE(HAVE_AS_IX86_FILDQ, 1,
3945 [Define if your assembler uses fildq and fistq mnemonics.])])
3947 gcc_GAS_CHECK_FEATURE([cmov syntax],
3948 gcc_cv_as_ix86_cmov_sun_syntax,,,
3949 [cmovl.l %edx, %eax],,
3950 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
3951 [Define if your assembler supports the Sun syntax for cmov.])])
3953 gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
3954 gcc_cv_as_ix86_ffreep,,,
3956 [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
3957 [Define if your assembler supports the ffreep mnemonic.])])
3959 gcc_GAS_CHECK_FEATURE([.quad directive],
3960 gcc_cv_as_ix86_quad,,,
3962 [AC_DEFINE(HAVE_AS_IX86_QUAD, 1,
3963 [Define if your assembler supports the .quad directive.])])
3965 gcc_GAS_CHECK_FEATURE([sahf mnemonic],
3966 gcc_cv_as_ix86_sahf,,,
3969 [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
3970 [Define if your assembler supports the sahf mnemonic in 64bit mode.])])
3972 gcc_GAS_CHECK_FEATURE([interunit movq mnemonic],
3973 gcc_cv_as_ix86_interunit_movq,,,
3977 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_INTERUNIT_MOVQ,
3978 [`if test $gcc_cv_as_ix86_interunit_movq = yes; then echo 1; else echo 0; fi`],
3979 [Define if your assembler supports interunit movq mnemonic.])
3981 gcc_GAS_CHECK_FEATURE([hle prefixes],
3982 gcc_cv_as_ix86_hle,,,
3983 [lock xacquire cmpxchg %esi, (%ecx)],,
3984 [AC_DEFINE(HAVE_AS_IX86_HLE, 1,
3985 [Define if your assembler supports HLE prefixes.])])
3987 gcc_GAS_CHECK_FEATURE([swap suffix],
3988 gcc_cv_as_ix86_swap,,,
3989 [movl.s %esp, %ebp],,
3990 [AC_DEFINE(HAVE_AS_IX86_SWAP, 1,
3991 [Define if your assembler supports the swap suffix.])])
3993 gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
3994 gcc_cv_as_ix86_diff_sect_delta,,,
4002 [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
4003 [Define if your assembler supports the subtraction of symbols in different sections.])])
4005 # These two are used unconditionally by i386.[ch]; it is to be defined
4006 # to 1 if the feature is present, 0 otherwise.
4007 as_ix86_gotoff_in_data_opt=
4008 if test x$gas = xyes; then
4009 as_ix86_gotoff_in_data_opt="--32"
4011 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
4012 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],
4013 [$as_ix86_gotoff_in_data_opt],
4019 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
4020 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
4021 [Define true if the assembler supports '.long foo@GOTOFF'.])
4023 gcc_GAS_CHECK_FEATURE([rep and lock prefix],
4024 gcc_cv_as_ix86_rep_lock_prefix,,,
4030 lock addl %edi, (%eax,%esi)
4031 lock orl $0, (%esp)],,
4032 [AC_DEFINE(HAVE_AS_IX86_REP_LOCK_PREFIX, 1,
4033 [Define if the assembler supports 'rep <insn>, lock <insn>'.])])
4035 gcc_GAS_CHECK_FEATURE([ud2 mnemonic],
4036 gcc_cv_as_ix86_ud2,,,
4038 [AC_DEFINE(HAVE_AS_IX86_UD2, 1,
4039 [Define if your assembler supports the 'ud2' mnemonic.])])
4041 gcc_GAS_CHECK_FEATURE([R_386_TLS_GD_PLT reloc],
4042 gcc_cv_as_ix86_tlsgdplt,,,
4043 [call tls_gd@tlsgdplt],
4044 [if test x$gcc_cv_ld != x \
4045 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4046 gcc_cv_as_ix86_tlsgdplt=yes
4049 [AC_DEFINE(HAVE_AS_IX86_TLSGDPLT, 1,
4050 [Define if your assembler and linker support @tlsgdplt.])])
4053 .section .tdata,"aw'$tls_section_flag'",@progbits
4055 .section .text,"ax",@progbits
4056 call tls_ld@tlsldmplt'
4057 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM_PLT reloc],
4058 gcc_cv_as_ix86_tlsldmplt,,,
4060 [if test x$gcc_cv_ld != x \
4061 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
4062 gcc_cv_as_ix86_tlsldmplt=yes
4065 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDMPLT,
4066 [`if test $gcc_cv_as_ix86_tlsldmplt = yes; then echo 1; else echo 0; fi`],
4067 [Define to 1 if your assembler and linker support @tlsldmplt.])
4069 # Enforce 32-bit output with gas and gld.
4070 if test x$gas = xyes; then
4071 as_ix86_tls_ldm_opt="--32"
4073 if echo "$ld_ver" | grep GNU > /dev/null; then
4074 if $gcc_cv_ld -V 2>/dev/null | grep elf_i386_sol2 > /dev/null; then
4075 ld_ix86_tls_ldm_opt="-melf_i386_sol2"
4077 ld_ix86_tls_ldm_opt="-melf_i386"
4081 .section .text,"ax",@progbits
4083 .type _start, @function
4085 leal value@tlsldm(%ebx), %eax
4086 call ___tls_get_addr@plt
4088 .section .tdata,"aw'$tls_section_flag'",@progbits
4089 .type value, @object
4091 gcc_GAS_CHECK_FEATURE([R_386_TLS_LDM reloc],
4092 gcc_cv_as_ix86_tlsldm,,
4093 [$as_ix86_tls_ldm_opt],
4095 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
4096 && $gcc_cv_ld $ld_ix86_tls_ldm_opt -o conftest conftest.o $ld_tls_libs -lc > /dev/null 2>&1; then
4097 if $gcc_cv_objdump -d conftest 2>/dev/null | grep nop > /dev/null \
4098 || dis conftest 2>/dev/null | grep nop > /dev/null; then
4099 gcc_cv_as_ix86_tlsldm=yes
4103 AC_DEFINE_UNQUOTED(HAVE_AS_IX86_TLSLDM,
4104 [`if test $gcc_cv_as_ix86_tlsldm = yes; then echo 1; else echo 0; fi`],
4105 [Define to 1 if your assembler and linker support @tlsldm.])
4110 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
4111 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
4113 addl r15 = @ltoffx(x#), gp
4115 ld8.mov r16 = [[r15]], x#],,
4116 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
4117 [Define if your assembler supports ltoffx and ldxmov relocations.])])
4123 *-*-aix*) conftest_s=' .machine "pwr5"
4127 gcc_GAS_CHECK_FEATURE([.machine directive support],
4128 gcc_cv_as_machine_directive,,,
4129 [ .machine ppc7400])
4130 if test x$gcc_cv_as_machine_directive != xyes; then
4131 echo "*** This target requires an assembler supporting \".machine\"" >&2
4132 echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
4133 test x$build = x$target && exit 1
4137 *) conftest_s=' .machine power4
4142 gcc_GAS_CHECK_FEATURE([mfcr field support],
4143 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
4145 [AC_DEFINE(HAVE_AS_MFCRF, 1,
4146 [Define if your assembler supports mfcr field.])])
4149 *-*-aix*) conftest_s=' .machine "pwr5"
4152 *) conftest_s=' .machine power5
4157 gcc_GAS_CHECK_FEATURE([popcntb support],
4158 gcc_cv_as_powerpc_popcntb, [2,17,0],,
4160 [AC_DEFINE(HAVE_AS_POPCNTB, 1,
4161 [Define if your assembler supports popcntb field.])])
4164 *-*-aix*) conftest_s=' .machine "pwr5x"
4167 *) conftest_s=' .machine power5
4172 gcc_GAS_CHECK_FEATURE([fp round support],
4173 gcc_cv_as_powerpc_fprnd, [2,17,0],,
4175 [AC_DEFINE(HAVE_AS_FPRND, 1,
4176 [Define if your assembler supports fprnd.])])
4179 *-*-aix*) conftest_s=' .machine "pwr6"
4182 *) conftest_s=' .machine power6
4187 gcc_GAS_CHECK_FEATURE([move fp gpr support],
4188 gcc_cv_as_powerpc_mfpgpr, [2,19,2],,
4190 [AC_DEFINE(HAVE_AS_MFPGPR, 1,
4191 [Define if your assembler supports mffgpr and mftgpr.])])
4194 *-*-aix*) conftest_s=' .csect .text[[PR]]
4196 addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
4200 addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
4201 *) conftest_s=' .text
4203 addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
4206 gcc_GAS_CHECK_FEATURE([rel16 relocs],
4207 gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
4209 [AC_DEFINE(HAVE_AS_REL16, 1,
4210 [Define if your assembler supports R_PPC_REL16 relocs.])])
4213 *-*-aix*) conftest_s=' .machine "pwr6"
4216 *) conftest_s=' .machine power6
4221 gcc_GAS_CHECK_FEATURE([compare bytes support],
4222 gcc_cv_as_powerpc_cmpb, [2,19,2], -a32,
4224 [AC_DEFINE(HAVE_AS_CMPB, 1,
4225 [Define if your assembler supports cmpb.])])
4228 *-*-aix*) conftest_s=' .machine "pwr6"
4231 *) conftest_s=' .machine power6
4236 gcc_GAS_CHECK_FEATURE([decimal float support],
4237 gcc_cv_as_powerpc_dfp, [2,19,2], -a32,
4239 [AC_DEFINE(HAVE_AS_DFP, 1,
4240 [Define if your assembler supports DFP instructions.])])
4243 *-*-aix*) conftest_s=' .machine "pwr7"
4246 *) conftest_s=' .machine power7
4251 gcc_GAS_CHECK_FEATURE([vector-scalar support],
4252 gcc_cv_as_powerpc_vsx, [2,19,2], -a32,
4254 [AC_DEFINE(HAVE_AS_VSX, 1,
4255 [Define if your assembler supports VSX instructions.])])
4258 *-*-aix*) conftest_s=' .machine "pwr7"
4261 *) conftest_s=' .machine power7
4266 gcc_GAS_CHECK_FEATURE([popcntd support],
4267 gcc_cv_as_powerpc_popcntd, [2,19,2], -a32,
4269 [AC_DEFINE(HAVE_AS_POPCNTD, 1,
4270 [Define if your assembler supports POPCNTD instructions.])])
4273 *-*-aix*) conftest_s=' .machine "pwr8"
4274 .csect .text[[PR]]';;
4275 *) conftest_s=' .machine power8
4279 gcc_GAS_CHECK_FEATURE([power8 support],
4280 gcc_cv_as_powerpc_power8, [2,19,2], -a32,
4282 [AC_DEFINE(HAVE_AS_POWER8, 1,
4283 [Define if your assembler supports POWER8 instructions.])])
4286 *-*-aix*) conftest_s=' .csect .text[[PR]]
4288 *) conftest_s=' .text
4292 gcc_GAS_CHECK_FEATURE([lwsync support],
4293 gcc_cv_as_powerpc_lwsync, [2,19,2], -a32,
4295 [AC_DEFINE(HAVE_AS_LWSYNC, 1,
4296 [Define if your assembler supports LWSYNC instructions.])])
4299 *-*-aix*) conftest_s=' .machine "476"
4302 *) conftest_s=' .machine "476"
4307 gcc_GAS_CHECK_FEATURE([data cache invalidate support],
4308 gcc_cv_as_powerpc_dci, [9,99,0], -a32,
4310 [AC_DEFINE(HAVE_AS_DCI, 1,
4311 [Define if your assembler supports the DCI/ICI instructions.])])
4313 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4314 gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
4315 [.gnu_attribute 4,1],,
4316 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4317 [Define if your assembler supports .gnu_attribute.])])
4319 gcc_GAS_CHECK_FEATURE([tls marker support],
4320 gcc_cv_as_powerpc_tls_markers, [2,20,0],,
4321 [ bl __tls_get_addr(x@tlsgd)],,
4322 [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
4323 [Define if your assembler supports arg info for __tls_get_addr.])])
4327 gcc_GAS_CHECK_FEATURE([.ref support],
4328 gcc_cv_as_aix_ref, [2,21,0],,
4329 [ .csect stuff[[rw]]
4335 [AC_DEFINE(HAVE_AS_REF, 1,
4336 [Define if your assembler supports .ref])])
4342 gcc_GAS_CHECK_FEATURE([explicit relocation support],
4343 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
4344 [ lw $4,%gp_rel(foo)($4)],,
4345 [if test x$target_cpu_default = x
4346 then target_cpu_default=MASK_EXPLICIT_RELOCS
4347 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
4349 gcc_GAS_CHECK_FEATURE([-mno-shared support],
4350 gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
4351 [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
4352 [Define if the assembler understands -mno-shared.])])
4354 gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
4355 gcc_cv_as_mips_gnu_attribute, [2,18,0],,
4356 [.gnu_attribute 4,1],,
4357 [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
4358 [Define if your assembler supports .gnu_attribute.])])
4360 gcc_GAS_CHECK_FEATURE([.micromips support],
4361 gcc_cv_as_micromips_support,,[--fatal-warnings],
4363 [AC_DEFINE(HAVE_GAS_MICROMIPS, 1,
4364 [Define if your assembler supports the .set micromips directive])])
4366 gcc_GAS_CHECK_FEATURE([.dtprelword support],
4367 gcc_cv_as_mips_dtprelword, [2,18,0],,
4368 [.section .tdata,"awT",@progbits
4372 .dtprelword x+0x8000],,
4373 [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
4374 [Define if your assembler supports .dtprelword.])])
4376 gcc_GAS_CHECK_FEATURE([DSPR1 mult with four accumulators support],
4377 gcc_cv_as_mips_dspr1_mult,,,
4387 [AC_DEFINE(HAVE_AS_DSPR1_MULT, 1,
4388 [Define if your assembler supports DSPR1 mult.])])
4390 AC_MSG_CHECKING(assembler and linker for explicit JALR relocation)
4391 gcc_cv_as_ld_jalr_reloc=no
4392 if test $gcc_cv_as_mips_explicit_relocs = yes; then
4393 if test $in_tree_ld = yes ; then
4394 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 \
4395 && test $in_tree_ld_is_elf = yes; then
4396 gcc_cv_as_ld_jalr_reloc=yes
4398 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x; then
4399 echo ' .ent x' > conftest.s
4400 echo 'x: ld $2,%got_disp(y)($3)' >> conftest.s
4401 echo ' ld $25,%call16(y)($28)' >> conftest.s
4402 echo ' .reloc 1f,R_MIPS_JALR,y' >> conftest.s
4403 echo '1: jalr $25' >> conftest.s
4404 echo ' .reloc 1f,R_MIPS_JALR,x' >> conftest.s
4405 echo '1: jalr $25' >> conftest.s
4406 echo ' .end x' >> conftest.s
4407 if $gcc_cv_as -o conftest.o conftest.s >/dev/null 2>&AS_MESSAGE_LOG_FD \
4408 && $gcc_cv_ld -shared -o conftest.so conftest.o >/dev/null 2>&AS_MESSAGE_LOG_FD; then
4409 if $gcc_cv_objdump -d conftest.so | grep jalr >/dev/null 2>&1 \
4410 && $gcc_cv_objdump -d conftest.so | grep "bal.*<x>" >/dev/null 2>&1; then
4411 gcc_cv_as_ld_jalr_reloc=yes
4417 if test $gcc_cv_as_ld_jalr_reloc = yes; then
4418 if test x$target_cpu_default = x; then
4419 target_cpu_default=MASK_RELAX_PIC_CALLS
4421 target_cpu_default="($target_cpu_default)|MASK_RELAX_PIC_CALLS"
4424 AC_MSG_RESULT($gcc_cv_as_ld_jalr_reloc)
4426 AC_CACHE_CHECK([linker for .eh_frame personality relaxation],
4427 [gcc_cv_ld_mips_personality_relaxation],
4428 [gcc_cv_ld_mips_personality_relaxation=no
4429 if test $in_tree_ld = yes ; then
4430 if test "$gcc_cv_gld_major_version" -eq 2 \
4431 -a "$gcc_cv_gld_minor_version" -ge 21 \
4432 -o "$gcc_cv_gld_major_version" -gt 2; then
4433 gcc_cv_ld_mips_personality_relaxation=yes
4435 elif test x$gcc_cv_as != x \
4436 -a x$gcc_cv_ld != x \
4437 -a x$gcc_cv_readelf != x ; then
4438 cat > conftest.s <<EOF
4440 .cfi_personality 0x80,indirect_ptr
4447 .section .data,"aw",@progbits
4451 if $gcc_cv_as -KPIC -o conftest.o conftest.s > /dev/null 2>&1 \
4452 && $gcc_cv_ld -o conftest conftest.o -shared > /dev/null 2>&1; then
4453 if $gcc_cv_readelf -d conftest 2>&1 \
4454 | grep TEXTREL > /dev/null 2>&1; then
4456 elif $gcc_cv_readelf --relocs conftest 2>&1 \
4457 | grep 'R_MIPS_REL32 *$' > /dev/null 2>&1; then
4460 gcc_cv_ld_mips_personality_relaxation=yes
4464 rm -f conftest.s conftest.o conftest])
4465 if test x$gcc_cv_ld_mips_personality_relaxation = xyes; then
4466 AC_DEFINE(HAVE_LD_PERSONALITY_RELAXATION, 1,
4467 [Define if your linker can relax absolute .eh_frame personality
4468 pointers into PC-relative form.])
4471 gcc_GAS_CHECK_FEATURE([-mnan= support],
4472 gcc_cv_as_mips_nan,,
4474 [AC_DEFINE(HAVE_AS_NAN, 1,
4475 [Define if the assembler understands -mnan=.])])
4476 if test x$gcc_cv_as_mips_nan = xno \
4477 && test x$with_nan != x; then
4479 [Requesting --with-nan= requires assembler support for -mnan=])
4484 # Mips and HP-UX need the GNU assembler.
4485 # Linux on IA64 might be able to use the Intel assembler.
4488 mips*-*-* | *-*-hpux* )
4489 if test x$gas_flag = xyes \
4490 || test x"$host" != x"$build" \
4491 || test ! -x "$gcc_cv_as" \
4492 || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
4495 echo "*** This configuration requires the GNU assembler" >&2
4501 # ??? Not all targets support dwarf2 debug_line, even within a version
4502 # of gas. Moreover, we need to emit a valid instruction to trigger any
4503 # info to the output file. So, as supported targets are added to gas 2.11,
4504 # add some instruction here to (also) show we expect this might work.
4505 # ??? Once 2.11 is released, probably need to add first known working
4506 # version to the per-target configury.
4508 aarch64 | alpha | arm | avr | bfin | cris | i386 | m32c | m68k | microblaze \
4509 | mips | nios2 | pa | rs6000 | score | sparc | spu | tilegx | tilepro \
4510 | xstormy16 | xtensa)
4520 if test x"$insn" != x; then
4522 .file 1 \"conftest.s\"
4525 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
4526 gcc_cv_as_dwarf2_debug_line,
4527 [elf,2,11,0],, [$conftest_s],
4528 [if test x$gcc_cv_objdump != x \
4529 && $gcc_cv_objdump -h conftest.o 2> /dev/null \
4530 | grep debug_line > /dev/null 2>&1; then
4531 gcc_cv_as_dwarf2_debug_line=yes
4534 # The .debug_line file table must be in the exact order that
4535 # we specified the files, since these indices are also used
4536 # by DW_AT_decl_file. Approximate this test by testing if
4537 # the assembler bitches if the same index is assigned twice.
4538 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
4539 gcc_cv_as_dwarf2_file_buggy,,,
4543 if test $gcc_cv_as_dwarf2_debug_line = yes \
4544 && test $gcc_cv_as_dwarf2_file_buggy = no; then
4545 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
4546 [Define if your assembler supports dwarf2 .file/.loc directives,
4547 and preserves file table indices exactly as given.])
4550 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
4551 gcc_cv_as_gdwarf2_flag,
4552 [elf,2,11,0], [--gdwarf2], [$insn],,
4553 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
4554 [Define if your assembler supports the --gdwarf2 option.])])
4556 gcc_GAS_CHECK_FEATURE([--gstabs option],
4557 gcc_cv_as_gstabs_flag,
4558 [elf,2,11,0], [--gstabs], [$insn],
4559 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
4560 # and warns about it, but still exits successfully. So check for
4562 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
4564 else gcc_cv_as_gstabs_flag=yes
4566 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
4567 [Define if your assembler supports the --gstabs option.])])
4569 gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
4570 gcc_cv_as_debug_prefix_map_flag,
4571 [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
4572 [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
4573 [Define if your assembler supports the --debug-prefix-map option.])])
4576 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
4579 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
4580 [Define if your assembler supports .lcomm with an alignment field.])])
4582 if test x$with_sysroot = x && test x$host = x$target \
4583 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
4584 && test "$prefix" != "NONE"; then
4585 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
4586 [Define to PREFIX/include if cpp should also search that directory.])
4589 if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
4590 if test "x$with_headers" != x; then
4591 target_header_dir=$with_headers
4592 elif test "x$with_sysroot" = x; then
4593 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-include"
4594 elif test "x$with_build_sysroot" != "x"; then
4595 target_header_dir="${with_build_sysroot}${native_system_header_dir}"
4596 elif test "x$with_sysroot" = xyes; then
4597 target_header_dir="${test_exec_prefix}/${target_noncanonical}/sys-root${native_system_header_dir}"
4599 target_header_dir="${with_sysroot}${native_system_header_dir}"
4602 target_header_dir=${native_system_header_dir}
4605 # Determine the version of glibc, if any, used on the target.
4606 AC_MSG_CHECKING([for target glibc version])
4607 AC_ARG_WITH([glibc-version],
4608 [AS_HELP_STRING([--with-glibc-version=M.N],
4609 [assume GCC used with glibc version M.N or later])], [
4610 if [echo "$with_glibc_version" | grep '^[0-9][0-9]*\.[0-9][0-9]*$']; then
4611 glibc_version_major=`echo "$with_glibc_version" | sed -e 's/\..*//'`
4612 glibc_version_minor=`echo "$with_glibc_version" | sed -e 's/.*\.//'`
4614 AC_MSG_ERROR([option --with-glibc-version requires a version number M.N])
4616 glibc_version_major=0
4617 glibc_version_minor=0
4618 [if test -f $target_header_dir/features.h \
4619 && glibc_version_major_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC__[ ]+[0-9]' $target_header_dir/features.h` \
4620 && glibc_version_minor_define=`$EGREP '^[ ]*#[ ]*define[ ]+__GLIBC_MINOR__[ ]+[0-9]' $target_header_dir/features.h`; then
4621 glibc_version_major=`echo "$glibc_version_major_define" | sed -e 's/.*__GLIBC__[ ]*//'`
4622 glibc_version_minor=`echo "$glibc_version_minor_define" | sed -e 's/.*__GLIBC_MINOR__[ ]*//'`
4624 AC_MSG_RESULT([$glibc_version_major.$glibc_version_minor])
4626 AC_ARG_ENABLE(gnu-unique-object,
4627 [AS_HELP_STRING([--enable-gnu-unique-object],
4628 [enable the use of the @gnu_unique_object ELF extension on glibc systems])],
4629 [case $enable_gnu_unique_object in
4631 *) AC_MSG_ERROR(['$enable_gnu_unique_object' is an invalid value for --enable-gnu-unique-object.
4632 Valid choices are 'yes' and 'no'.]) ;;
4634 [gcc_GAS_CHECK_FEATURE([gnu_unique_object], gcc_cv_as_gnu_unique_object,
4636 [.type foo, '$target_type_format_char'gnu_unique_object],,
4637 # We need to unquote above to to use the definition from config.gcc.
4638 # Also check for ld.so support, i.e. glibc 2.11 or higher.
4639 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [11], [enable_gnu_unique_object=yes], )]
4641 if test x$enable_gnu_unique_object = xyes; then
4642 AC_DEFINE(HAVE_GAS_GNU_UNIQUE_OBJECT, 1,
4643 [Define if your assembler supports @gnu_unique_object.])
4646 AC_CACHE_CHECK([assembler for tolerance to line number 0],
4647 [gcc_cv_as_line_zero],
4648 [gcc_cv_as_line_zero=no
4649 if test $in_tree_gas = yes; then
4650 gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
4651 elif test "x$gcc_cv_as" != x; then
4652 { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
4653 if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
4654 test "x`cat conftest.out`" = x
4656 gcc_cv_as_line_zero=yes
4658 echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
4659 cat conftest.s >&AS_MESSAGE_LOG_FD
4660 echo "configure: error output was" >&AS_MESSAGE_LOG_FD
4661 cat conftest.out >&AS_MESSAGE_LOG_FD
4663 rm -f conftest.o conftest.s conftest.out
4665 if test "x$gcc_cv_as_line_zero" = xyes; then
4666 AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
4667 [Define if the assembler won't complain about a line such as # 0 "" 2.])
4670 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
4671 gcc_cv_ld_eh_frame_hdr=no
4672 if test $in_tree_ld = yes ; then
4673 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 \
4674 && test $in_tree_ld_is_elf = yes; then
4675 gcc_cv_ld_eh_frame_hdr=yes
4677 elif test x$gcc_cv_ld != x; then
4678 if echo "$ld_ver" | grep GNU > /dev/null; then
4679 # Check if linker supports --eh-frame-hdr option
4680 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
4681 gcc_cv_ld_eh_frame_hdr=yes
4686 # Sun ld has various bugs in .eh_frame_hdr support before version 1.2251.
4687 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2251; then
4688 gcc_cv_ld_eh_frame_hdr=yes
4694 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
4695 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
4696 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
4697 [Define if your linker supports .eh_frame_hdr.])
4699 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
4701 AC_MSG_CHECKING(linker CIEv3 in .eh_frame support)
4702 gcc_cv_ld_eh_frame_ciev3=no
4703 if test $in_tree_ld = yes ; then
4704 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 \
4705 && test $in_tree_ld_is_elf = yes; then
4706 gcc_cv_ld_eh_frame_ciev3=yes
4708 elif test x$gcc_cv_ld != x; then
4709 if echo "$ld_ver" | grep GNU > /dev/null; then
4710 gcc_cv_ld_eh_frame_ciev3=yes
4711 if test 0"$ld_date" -lt 20040513; then
4712 if test -n "$ld_date"; then
4713 # If there was date string, but was earlier than 2004-05-13, fail
4714 gcc_cv_ld_eh_frame_ciev3=no
4715 elif test "$ld_vers_major" -lt 2; then
4716 gcc_cv_ld_eh_frame_ciev3=no
4717 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
4718 gcc_cv_ld_eh_frame_ciev3=no
4724 # Sun ld added support for CIE v3 in .eh_frame in Solaris 11.1.
4725 if test "$ld_vers_major" -gt 1 || test "$ld_vers_minor" -ge 2324; then
4726 gcc_cv_ld_eh_frame_ciev3=yes
4732 AC_DEFINE_UNQUOTED(HAVE_LD_EH_FRAME_CIEV3,
4733 [`if test x"$gcc_cv_ld_eh_frame_ciev3" = xyes; then echo 1; else echo 0; fi`],
4734 [Define 0/1 if your linker supports CIE v3 in .eh_frame.])
4735 AC_MSG_RESULT($gcc_cv_ld_eh_frame_ciev3)
4737 AC_MSG_CHECKING(linker position independent executable support)
4739 if test $in_tree_ld = yes ; then
4740 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 \
4741 && test $in_tree_ld_is_elf = yes; then
4744 elif test x$gcc_cv_ld != x; then
4745 # Check if linker supports -pie option
4746 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
4750 if test x"$gcc_cv_ld_pie" = xyes; then
4751 AC_DEFINE(HAVE_LD_PIE, 1,
4752 [Define if your linker supports -pie option.])
4754 AC_MSG_RESULT($gcc_cv_ld_pie)
4756 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
4757 gcc_cv_ld_eh_gc_sections=no
4758 if test $in_tree_ld = yes ; then
4759 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 \
4760 && test $in_tree_ld_is_elf = yes; then
4761 gcc_cv_ld_eh_gc_sections=yes
4763 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
4764 cat > conftest.s <<EOF
4767 .type _start, @function
4770 .size _start, .-_start
4771 .section .text.foo,"ax",@progbits
4772 .type foo, @function
4776 .section .gcc_except_table.foo,"a",@progbits
4779 .section .eh_frame,"a",@progbits
4782 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4783 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4784 | grep "gc-sections option ignored" > /dev/null; then
4785 gcc_cv_ld_eh_gc_sections=no
4786 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4787 | grep gcc_except_table > /dev/null; then
4788 gcc_cv_ld_eh_gc_sections=yes
4789 # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
4790 if test x$gcc_cv_as_comdat_group != xyes; then
4791 gcc_cv_ld_eh_gc_sections=no
4792 cat > conftest.s <<EOF
4795 .type _start, @function
4798 .size _start, .-_start
4799 .section .gnu.linkonce.t.foo,"ax",@progbits
4800 .type foo, @function
4804 .section .gcc_except_table.foo,"a",@progbits
4807 .section .eh_frame,"a",@progbits
4810 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4811 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4812 | grep "gc-sections option ignored" > /dev/null; then
4813 gcc_cv_ld_eh_gc_sections=no
4814 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4815 | grep gcc_except_table > /dev/null; then
4816 gcc_cv_ld_eh_gc_sections=yes
4822 rm -f conftest.s conftest.o conftest
4826 # ??? This apparently exposes a binutils bug with PC-relative relocations.
4827 gcc_cv_ld_eh_gc_sections=no
4830 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
4831 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
4832 [Define if your linker supports garbage collection of
4833 sections in presence of EH frames.])
4835 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
4837 AC_MSG_CHECKING(linker EH garbage collection of sections bug)
4838 gcc_cv_ld_eh_gc_sections_bug=no
4839 if test $in_tree_ld = yes ; then
4840 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 \
4841 && test $in_tree_ld_is_elf = yes; then
4842 gcc_cv_ld_eh_gc_sections_bug=yes
4844 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
4845 gcc_cv_ld_eh_gc_sections_bug=yes
4846 cat > conftest.s <<EOF
4849 .type _start, @function
4852 .size _start, .-_start
4853 .section .text.startup.foo,"ax",@progbits
4854 .type foo, @function
4858 .section .gcc_except_table.foo,"a",@progbits
4861 .section .eh_frame,"a",@progbits
4864 if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
4865 if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
4866 | grep "gc-sections option ignored" > /dev/null; then
4868 elif $gcc_cv_objdump -h conftest 2> /dev/null \
4869 | grep gcc_except_table > /dev/null; then
4870 gcc_cv_ld_eh_gc_sections_bug=no
4873 rm -f conftest.s conftest.o conftest
4875 if test x$gcc_cv_ld_eh_gc_sections_bug = xyes; then
4876 AC_DEFINE(HAVE_LD_EH_GC_SECTIONS_BUG, 1,
4877 [Define if your linker has buggy garbage collection of
4878 sections support when .text.startup.foo like sections are used.])
4880 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections_bug)
4886 AC_CACHE_CHECK(linker --as-needed support,
4887 gcc_cv_ld_as_needed,
4888 [gcc_cv_ld_as_needed=no
4889 gcc_cv_ld_as_needed_option='--as-needed'
4890 gcc_cv_ld_no_as_needed_option='--no-as-needed'
4891 if test $in_tree_ld = yes ; then
4892 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 \
4893 && test $in_tree_ld_is_elf = yes; then
4894 gcc_cv_ld_as_needed=yes
4896 elif test x$gcc_cv_ld != x; then
4897 # Check if linker supports --as-needed and --no-as-needed options
4898 if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
4899 gcc_cv_ld_as_needed=yes
4902 # Solaris 2 ld always supports -z ignore/-z record.
4904 gcc_cv_ld_as_needed=yes
4905 gcc_cv_ld_as_needed_option="-z ignore"
4906 gcc_cv_ld_no_as_needed_option="-z record"
4911 # --as-needed/-z ignore can only be used if libgcc_s.so.1 uses
4912 # dl_iterate_phdr, i.e. since Solaris 11.
4914 *-*-solaris2.1[[1-9]]*)
4916 i?86-*-* | x86_64-*-*)
4917 if echo "$ld_ver" | grep GNU > /dev/null; then
4918 # Doesn't work with gld on Solaris/x86 due to PR ld/12320.
4919 gcc_cv_ld_as_needed=no
4925 gcc_cv_ld_as_needed=no
4929 if test x"$gcc_cv_ld_as_needed" = xyes; then
4930 AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
4931 [Define if your linker supports --as-needed/--no-as-needed or equivalent options.])
4932 AC_DEFINE_UNQUOTED(LD_AS_NEEDED_OPTION, "$gcc_cv_ld_as_needed_option",
4933 [Define to the linker option to ignore unused dependencies.])
4934 AC_DEFINE_UNQUOTED(LD_NO_AS_NEEDED_OPTION, "$gcc_cv_ld_no_as_needed_option",
4935 [Define to the linker option to keep unused dependencies.])
4938 case "$target:$tm_file" in
4939 powerpc64-*-freebsd* | powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
4942 emul_name="-melf64lppc"
4945 emul_name="-melf64ppc"
4948 emul_name="-melf64ppc_fbsd"
4951 AC_CACHE_CHECK(linker support for omitting dot symbols,
4952 gcc_cv_ld_no_dot_syms,
4953 [gcc_cv_ld_no_dot_syms=no
4954 if test x"$ld_is_gold" = xyes; then
4955 gcc_cv_ld_no_dot_syms=yes
4956 elif test $in_tree_ld = yes ; then
4957 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
4958 gcc_cv_ld_no_dot_syms=yes
4960 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
4961 cat > conftest1.s <<EOF
4965 cat > conftest2.s <<EOF
4966 .section ".opd","aw"
4971 .quad .LEfoo,.TOC.@tocbase,0
4977 if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
4978 && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
4979 && $gcc_cv_ld $emul_name -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
4980 gcc_cv_ld_no_dot_syms=yes
4982 rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
4985 if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
4986 AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
4987 [Define if your PowerPC64 linker only needs function descriptor syms.])
4990 AC_CACHE_CHECK(linker large toc support,
4991 gcc_cv_ld_large_toc,
4992 [gcc_cv_ld_large_toc=no
4993 if test x"$ld_is_gold" = xyes; then
4994 gcc_cv_ld_large_toc=yes
4995 elif test $in_tree_ld = yes ; then
4996 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
4997 gcc_cv_ld_large_toc=yes
4999 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
5000 cat > conftest.s <<EOF
5001 .section ".tbss","awT",@nobits
5007 addis 9,13,ie0@got@tprel@ha
5008 ld 9,ie0@got@tprel@l(9)
5010 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1 \
5011 && $gcc_cv_ld $emul_name --no-toc-sort -o conftest conftest.o > /dev/null 2>&1; then
5012 gcc_cv_ld_large_toc=yes
5014 rm -f conftest conftest.o conftest.s
5017 if test x"$gcc_cv_ld_large_toc" = xyes; then
5018 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5019 [Define if your PowerPC64 linker supports a large TOC.])
5026 AC_CACHE_CHECK(linker large toc support,
5027 gcc_cv_ld_large_toc,
5028 [gcc_cv_ld_large_toc=no
5029 if test x$gcc_cv_as != x ; then
5030 cat > conftest.s <<EOF
5040 if $gcc_cv_as -a64 -o conftest.o conftest.s > /dev/null 2>&1; then
5041 gcc_cv_ld_large_toc=yes
5043 rm -f conftest conftest.o conftest.s
5046 if test x"$gcc_cv_ld_large_toc" = xyes; then
5047 AC_DEFINE(HAVE_LD_LARGE_TOC, 1,
5048 [Define if your PowerPC64 linker supports a large TOC.])
5053 AC_CACHE_CHECK(linker --build-id support,
5055 [gcc_cv_ld_buildid=no
5056 if test $in_tree_ld = yes ; then
5057 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5058 "$gcc_cv_gld_minor_version" -ge 18 -o \
5059 "$gcc_cv_gld_major_version" -gt 2 \
5060 && test $in_tree_ld_is_elf = yes; then
5061 gcc_cv_ld_buildid=yes
5063 elif test x$gcc_cv_ld != x; then
5064 if $gcc_cv_ld --help 2>/dev/null | grep build-id > /dev/null; then
5065 gcc_cv_ld_buildid=yes
5068 if test x"$gcc_cv_ld_buildid" = xyes; then
5069 AC_DEFINE(HAVE_LD_BUILDID, 1,
5070 [Define if your linker supports --build-id.])
5073 AC_ARG_ENABLE(linker-build-id,
5074 [AS_HELP_STRING([--enable-linker-build-id],
5075 [compiler will always pass --build-id to linker])],
5077 enable_linker_build_id=no)
5079 if test x"$enable_linker_build_id" = xyes; then
5080 if test x"$gcc_cv_ld_buildid" = xyes; then
5081 AC_DEFINE(ENABLE_LD_BUILDID, 1,
5082 [Define if gcc should always pass --build-id to linker.])
5084 AC_MSG_WARN(--build-id is not supported by your linker; --enable-linker-build-id ignored)
5088 # In binutils 2.21, GNU ld gained support for new emulations fully
5089 # supporting the Solaris 2 ABI. Detect their presence in the linker used.
5090 AC_CACHE_CHECK(linker *_sol2 emulation support,
5091 gcc_cv_ld_sol2_emulation,
5092 [gcc_cv_ld_sol2_emulation=no
5093 if test $in_tree_ld = yes ; then
5094 if test "$gcc_cv_gld_major_version" -eq 2 -a \
5095 "$gcc_cv_gld_minor_version" -ge 21 -o \
5096 "$gcc_cv_gld_major_version" -gt 2 \
5097 && test $in_tree_ld_is_elf = yes; then
5098 gcc_cv_ld_sol2_emulation=yes
5100 elif test x$gcc_cv_ld != x; then
5101 if $gcc_cv_ld -V 2>/dev/null | sed -e '1,/Supported emulations/d;q' | \
5102 grep _sol2 > /dev/null; then
5103 gcc_cv_ld_sol2_emulation=yes
5106 if test x"$gcc_cv_ld_sol2_emulation" = xyes; then
5107 AC_DEFINE(HAVE_LD_SOL2_EMULATION, 1,
5108 [Define if your linker supports the *_sol2 emulations.])
5111 AC_CACHE_CHECK(linker --sysroot support,
5113 [gcc_cv_ld_sysroot=no
5114 if test $in_tree_ld = yes ; then
5115 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
5116 gcc_cv_ld_sysroot=yes
5118 elif test x$gcc_cv_ld != x; then
5119 if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
5120 gcc_cv_ld_sysroot=yes
5123 if test x"$gcc_cv_ld_sysroot" = xyes; then
5124 AC_DEFINE(HAVE_LD_SYSROOT, 1,
5125 [Define if your linker supports --sysroot.])
5128 # Test for stack protector support in target C library.
5129 AC_CACHE_CHECK(__stack_chk_fail in target C library,
5130 gcc_cv_libc_provides_ssp,
5131 [gcc_cv_libc_provides_ssp=no
5133 *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
5134 # glibc 2.4 and later provides __stack_chk_fail and
5135 # either __stack_chk_guard, or TLS access to stack guard canary.
5136 GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_libc_provides_ssp=yes], [
5137 [if test -f $target_header_dir/features.h \
5138 && $EGREP '^[ ]*#[ ]*define[ ]+__GNU_LIBRARY__[ ]+([1-9][0-9]|[6-9])' \
5139 $target_header_dir/features.h > /dev/null; then
5140 if $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC__[ ]+1' \
5141 $target_header_dir/features.h > /dev/null && \
5142 test -f $target_header_dir/bits/uClibc_config.h && \
5143 $EGREP '^[ ]*#[ ]*define[ ]+__UCLIBC_HAS_SSP__[ ]+1' \
5144 $target_header_dir/bits/uClibc_config.h > /dev/null; then
5145 gcc_cv_libc_provides_ssp=yes
5147 # all versions of Bionic support stack protector
5148 elif test -f $target_header_dir/sys/cdefs.h \
5149 && $EGREP '^[ ]*#[ ]*define[ ]+__BIONIC__[ ]+1' \
5150 $target_header_dir/sys/cdefs.h > /dev/null; then
5151 gcc_cv_libc_provides_ssp=yes
5155 # Avoid complicated tests (see
5156 # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
5157 # simply assert that glibc does provide this, which is true for all
5158 # realistically usable GNU/Hurd configurations.
5159 gcc_cv_libc_provides_ssp=yes;;
5160 *-*-darwin* | *-*-freebsd*)
5161 AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
5162 [echo "no __stack_chk_fail on this target"])
5164 *) gcc_cv_libc_provides_ssp=no ;;
5167 if test x$gcc_cv_libc_provides_ssp = xyes; then
5168 AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
5169 [Define if your target C library provides stack protector support])
5172 # Test for <sys/sdt.h> on the target.
5173 GCC_TARGET_TEMPLATE([HAVE_SYS_SDT_H])
5174 AC_MSG_CHECKING(sys/sdt.h in the target C library)
5176 if test -f $target_header_dir/sys/sdt.h; then
5178 AC_DEFINE(HAVE_SYS_SDT_H, 1,
5179 [Define if your target C library provides sys/sdt.h])
5181 AC_MSG_RESULT($have_sys_sdt_h)
5183 # Check if TFmode long double should be used by default or not.
5184 # Some glibc targets used DFmode long double, but with glibc 2.4
5185 # and later they can use TFmode.
5187 powerpc*-*-linux* | \
5191 AC_ARG_WITH(long-double-128,
5192 [AS_HELP_STRING([--with-long-double-128],
5193 [use 128-bit long double by default])],
5194 gcc_cv_target_ldbl128="$with_long_double_128",
5195 [GCC_GLIBC_VERSION_GTE_IFELSE([2], [4], [gcc_cv_target_ldbl128=yes], [
5196 [gcc_cv_target_ldbl128=no
5197 grep '^[ ]*#[ ]*define[ ][ ]*__LONG_DOUBLE_MATH_OPTIONAL' \
5198 $target_header_dir/bits/wordsize.h > /dev/null 2>&1 \
5199 && gcc_cv_target_ldbl128=yes
5203 if test x$gcc_cv_target_ldbl128 = xyes; then
5204 AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
5205 [Define if TFmode long double should be the default])
5208 AC_MSG_CHECKING(dl_iterate_phdr in target C library)
5209 gcc_cv_target_dl_iterate_phdr=unknown
5211 # Restrict to Solaris 11+. While most of the Solaris 11 linker changes
5212 # were backported to Solaris 10 Update 10, dl_iterate_phdr only lives in
5213 # libdl there, both complicating its use and breaking compatibility
5214 # between Solaris 10 updates.
5215 *-*-solaris2.1[[1-9]]*)
5216 # <link.h> needs both a dl_iterate_phdr declaration and support for
5217 # compilation with largefile support.
5218 if grep dl_iterate_phdr $target_header_dir/link.h > /dev/null 2>&1 \
5219 && grep 'large file capable' $target_header_dir/link.h > /dev/null 2>&1; then
5220 gcc_cv_target_dl_iterate_phdr=yes
5222 gcc_cv_target_dl_iterate_phdr=no
5226 GCC_TARGET_TEMPLATE([TARGET_DL_ITERATE_PHDR])
5227 if test x$gcc_cv_target_dl_iterate_phdr = xyes; then
5228 AC_DEFINE(TARGET_DL_ITERATE_PHDR, 1,
5229 [Define if your target C library provides the `dl_iterate_phdr' function.])
5231 AC_MSG_RESULT($gcc_cv_target_dl_iterate_phdr)
5233 # We no longer support different GC mechanisms. Emit an error if
5234 # the user configures with --with-gc.
5236 [AS_HELP_STRING([--with-gc={page,zone}],
5237 [this option is not supported anymore. It used to choose
5238 the garbage collection mechanism to use with the compiler])],
5239 [AC_MSG_ERROR([Configure option --with-gc is only supported up to GCC 4.7.x])],
5242 # Libraries to use on the host. This will normally be set by the top
5243 # level Makefile. Here we simply capture the value for our Makefile.
5244 if test -z "${HOST_LIBS+set}"; then
5249 # Use the system's zlib library.
5251 zlibinc="-I\$(srcdir)/../zlib"
5252 AC_ARG_WITH(system-zlib,
5253 [AS_HELP_STRING([--with-system-zlib], [use installed libz])],
5260 dnl Very limited version of automake's enable-maintainer-mode
5262 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
5263 dnl maintainer-mode is disabled by default
5264 AC_ARG_ENABLE(maintainer-mode,
5265 [AS_HELP_STRING([--enable-maintainer-mode],
5266 [enable make rules and dependencies not useful
5267 (and sometimes confusing) to the casual installer])],
5268 maintainer_mode=$enableval,
5271 AC_MSG_RESULT($maintainer_mode)
5273 if test "$maintainer_mode" = "yes"; then
5280 dnl Whether to prevent multiple front-ends from linking at the same time
5282 AC_MSG_CHECKING([whether to avoid linking multiple front-ends at once])
5283 AC_ARG_ENABLE(link-mutex,
5284 [AS_HELP_STRING([--enable-link-mutex],
5285 [avoid linking multiple front-ends at once to avoid thrashing
5286 on the build machine])],
5287 do_link_mutex=$enableval,
5289 AC_MSG_RESULT($do_link_mutex)
5291 if test "$do_link_mutex" = "yes"; then
5296 AC_SUBST(DO_LINK_MUTEX)
5302 # Make empty files to contain the specs and options for each language.
5303 # Then add #include lines to for a compiler that has specs and/or options.
5309 # These (without "all_") are set in each config-lang.in.
5310 # `language' must be a single word so is spelled singularly.
5313 all_outputs='Makefile'
5314 # List of language makefile fragments.
5316 # Additional files for gengtype
5317 all_gtfiles="$target_gtfiles"
5319 # These are the languages that are set in --enable-languages,
5320 # and are available in the GCC tree.
5321 all_selected_languages=
5323 # Add the language fragments.
5324 # Languages are added via two mechanisms. Some information must be
5325 # recorded in makefile variables, these are defined in config-lang.in.
5326 # We accumulate them and plug them into the main Makefile.
5327 # The other mechanism is a set of hooks for each of the main targets
5328 # like `clean', `install', etc.
5330 language_hooks="Make-hooks"
5332 for lang in ${srcdir}/*/config-lang.in
5335 test "$lang" = "${srcdir}/*/config-lang.in" && continue
5337 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
5338 if test "x$lang_alias" = x
5340 echo "$lang doesn't set \$language." 1>&2
5343 subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
5344 subdirs="$subdirs $subdir"
5346 # $gcc_subdir is where the gcc integration files are to be found
5347 # for a language, both for internal compiler purposes (compiler
5348 # sources implementing front-end to GCC tree converters), and for
5349 # build infrastructure purposes (Make-lang.in, etc.)
5351 # This will be <subdir> (relative to $srcdir) if a line like
5352 # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
5353 # is found in <langdir>/config-lang.in, and will remain <langdir>
5356 # Except for the language alias (fetched above), the regular
5357 # "config-lang.in" contents are always retrieved from $gcc_subdir,
5358 # so a <langdir>/config-lang.in setting gcc_subdir typically sets
5359 # only this and the language alias.
5361 gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^ ]*\).*$,\1,p' $lang`
5362 if [ "$gcc_subdir" = "" ]; then
5363 gcc_subdir="$subdir"
5366 case ",$enable_languages," in
5368 all_selected_languages="$all_selected_languages $lang_alias"
5369 if test -f $srcdir/$gcc_subdir/lang-specs.h; then
5370 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
5382 . ${srcdir}/$gcc_subdir/config-lang.in
5383 if test "x$language" = x
5385 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
5390 case ",$enable_languages," in
5393 for i in $subdir_requires; do
5394 test -f "${srcdir}/$i/config-lang.in" && continue
5402 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
5403 if test -f $srcdir/$gcc_subdir/lang.opt; then
5404 lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
5405 all_opt_files="$all_opt_files $srcdir/$gcc_subdir/lang.opt"
5407 if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
5408 lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
5410 all_languages="$all_languages $language"
5411 all_compilers="$all_compilers $compilers"
5412 all_outputs="$all_outputs $outputs"
5413 all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
5414 case ",$enable_languages," in
5416 AC_DEFINE(ENABLE_LTO, 1, [Define to enable LTO support.])
5418 AC_SUBST(enable_lto)
5425 for language in $all_selected_languages
5427 check_languages="$check_languages check-$language"
5430 # We link each language in with a set of hooks, reached indirectly via
5431 # lang.${target}. Only do so for selected languages.
5435 target_list="all.cross start.encap rest.encap tags \
5436 install-common install-man install-info install-pdf install-html dvi \
5437 pdf html uninstall info man srcextra srcman srcinfo \
5438 mostlyclean clean distclean maintainer-clean install-plugin"
5440 for t in $target_list
5443 for lang in $all_selected_languages
5447 echo "lang.$t: $x" >> Make-hooks
5451 # Option include files
5454 ${AWK} -f $srcdir/opt-include.awk $all_opt_files > option-includes.mk
5455 option_includes="option-includes.mk"
5456 AC_SUBST_FILE(option_includes)
5464 echo "dir ." > .gdbinit
5465 echo "dir ${srcdir}" >> .gdbinit
5466 if test x$gdb_needs_out_file_path = xyes
5468 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
5470 if test "x$subdirs" != x; then
5473 echo "dir ${srcdir}/$s" >> .gdbinit
5476 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
5477 echo "python import sys; sys.path.append('${srcdir}'); import gdbhooks" >> .gdbinit
5479 # Put a breakpoint on __asan_report_error to help with debugging buffer
5482 *-fsanitize=address*)
5483 echo "source ${srcdir}/gdbasan.in" >> .gdbinit
5487 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
5488 AC_SUBST(gcc_tooldir)
5491 # Find a directory in which to install a shared libgcc.
5493 AC_ARG_ENABLE(version-specific-runtime-libs,
5494 [AS_HELP_STRING([--enable-version-specific-runtime-libs],
5495 [specify that runtime libraries should be
5496 installed in a compiler-specific directory])])
5498 # Substitute configuration variables
5501 AC_SUBST(all_compilers)
5502 AC_SUBST(all_gtfiles)
5503 AC_SUBST(all_lang_makefrags)
5504 AC_SUBST(all_languages)
5505 AC_SUBST(all_selected_languages)
5506 AC_SUBST(build_exeext)
5507 AC_SUBST(build_install_headers_dir)
5508 AC_SUBST(build_xm_file_list)
5509 AC_SUBST(build_xm_include_list)
5510 AC_SUBST(build_xm_defines)
5511 AC_SUBST(build_file_translate)
5512 AC_SUBST(check_languages)
5513 AC_SUBST(cpp_install_dir)
5514 AC_SUBST(xmake_file)
5515 AC_SUBST(tmake_file)
5516 AC_SUBST(TM_ENDIAN_CONFIG)
5517 AC_SUBST(TM_MULTILIB_CONFIG)
5518 AC_SUBST(TM_MULTILIB_EXCEPTIONS_CONFIG)
5519 AC_SUBST(extra_gcc_objs)
5520 AC_SUBST(user_headers_inc_next_pre)
5521 AC_SUBST(user_headers_inc_next_post)
5522 AC_SUBST(extra_headers_list)
5523 AC_SUBST(extra_objs)
5524 AC_SUBST(extra_programs)
5525 AC_SUBST(float_h_file)
5526 AC_SUBST(gcc_config_arguments)
5527 AC_SUBST(gcc_gxx_include_dir)
5528 AC_SUBST(gcc_gxx_include_dir_add_sysroot)
5529 AC_SUBST(host_exeext)
5530 AC_SUBST(host_xm_file_list)
5531 AC_SUBST(host_xm_include_list)
5532 AC_SUBST(host_xm_defines)
5533 AC_SUBST(out_host_hook_obj)
5535 AC_SUBST(lang_opt_files)
5536 AC_SUBST(lang_specs_files)
5537 AC_SUBST(lang_tree_files)
5538 AC_SUBST(local_prefix)
5540 AC_SUBST(objc_boehm_gc)
5542 AC_SUBST(out_object_file)
5543 AC_SUBST(common_out_file)
5544 AC_SUBST(common_out_object_file)
5545 AC_SUBST(tm_file_list)
5546 AC_SUBST(tm_include_list)
5547 AC_SUBST(tm_defines)
5548 AC_SUBST(tm_p_file_list)
5549 AC_SUBST(tm_p_include_list)
5550 AC_SUBST(xm_file_list)
5551 AC_SUBST(xm_include_list)
5552 AC_SUBST(xm_defines)
5553 AC_SUBST(use_gcc_stdint)
5554 AC_SUBST(c_target_objs)
5555 AC_SUBST(cxx_target_objs)
5556 AC_SUBST(fortran_target_objs)
5557 AC_SUBST(target_cpu_default)
5559 AC_SUBST_FILE(language_hooks)
5562 if test x${build} = x${host} ; then
5563 if test x${host} = x${target} ; then
5564 echo "Links are now set up to build a native compiler for ${target}." 1>&2
5566 echo "Links are now set up to build a cross-compiler" 1>&2
5567 echo " from ${host} to ${target}." 1>&2
5570 if test x${host} = x${target} ; then
5571 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
5572 echo " for ${target}." 1>&2
5574 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
5575 echo " from ${host} to ${target}." 1>&2
5579 AC_ARG_VAR(GMPLIBS,[How to link GMP])
5580 AC_ARG_VAR(GMPINC,[How to find GMP include files])
5582 AC_ARG_VAR(ISLLIBS,[How to link ISL])
5583 AC_ARG_VAR(ISLINC,[How to find ISL include files])
5585 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
5586 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
5587 if test "x${CLOOGLIBS}" != "x" ; then
5588 AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
5591 # Check for plugin support
5592 AC_ARG_ENABLE(plugin,
5593 [AS_HELP_STRING([--enable-plugin], [enable plugin support])],
5594 enable_plugin=$enableval,
5595 enable_plugin=yes; default_plugin=yes)
5601 if test x$build = x$host; then
5602 export_sym_check="nm${exeext} -g"
5603 elif test x$host = x$target; then
5604 export_sym_check="$gcc_cv_nm -g"
5610 if test x$build = x$host; then
5611 export_sym_check="objdump${exeext} -T"
5612 elif test x$host = x$target; then
5613 export_sym_check="$gcc_cv_objdump -T"
5620 if test x"$enable_plugin" = x"yes"; then
5622 AC_MSG_CHECKING([for exported symbols])
5623 if test "x$export_sym_check" != x; then
5624 echo "int main() {return 0;} int foobar() {return 0;}" > conftest.c
5625 ${CC} ${CFLAGS} ${LDFLAGS} conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5626 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5627 : # No need to use a flag
5628 AC_MSG_RESULT([yes])
5630 AC_MSG_RESULT([yes])
5631 AC_MSG_CHECKING([for -rdynamic])
5632 ${CC} ${CFLAGS} ${LDFLAGS} -rdynamic conftest.c -o conftest$ac_exeext > /dev/null 2>&1
5633 if $export_sym_check conftest$ac_exeext | grep -q foobar > /dev/null; then
5635 pluginlibs="-rdynamic"
5640 AC_MSG_RESULT([$plugin_rdynamic])
5643 AC_MSG_RESULT([unable to check])
5648 AC_SEARCH_LIBS([dlopen], [dl])
5649 if test x"$ac_cv_search_dlopen" = x"-ldl"; then
5650 pluginlibs="$pluginlibs -ldl"
5654 # Check that we can build shared objects with -fPIC -shared
5655 saved_LDFLAGS="$LDFLAGS"
5656 saved_CFLAGS="$CFLAGS"
5659 CFLAGS=`echo $CFLAGS | sed s/-mdynamic-no-pic//g`
5660 CFLAGS="$CFLAGS -fPIC"
5661 LDFLAGS="$LDFLAGS -shared -undefined dynamic_lookup"
5664 CFLAGS="$CFLAGS -fPIC"
5665 LDFLAGS="$LDFLAGS -fPIC -shared"
5668 AC_MSG_CHECKING([for -fPIC -shared])
5670 [extern int X;],[return X == 0;],
5671 [AC_MSG_RESULT([yes]); have_pic_shared=yes],
5672 [AC_MSG_RESULT([no]); have_pic_shared=no])
5673 if test x"$have_pic_shared" != x"yes" -o x"$ac_cv_search_dlopen" = x"no"; then
5677 LDFLAGS="$saved_LDFLAGS"
5678 CFLAGS="$saved_CFLAGS"
5680 # If plugin support had been requested but not available, fail.
5681 if test x"$enable_plugin" = x"no" ; then
5682 if test x"$default_plugin" != x"yes"; then
5684 Building GCC with plugin support requires a host that supports
5685 -fPIC, -shared, -ldl and -rdynamic.])
5690 AC_SUBST(pluginlibs)
5691 AC_SUBST(enable_plugin)
5692 if test x"$enable_plugin" = x"yes"; then
5693 AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
5697 # Enable --enable-host-shared
5698 AC_ARG_ENABLE(host-shared,
5699 [AS_HELP_STRING([--enable-host-shared],
5700 [build host code as shared libraries])],
5701 [PICFLAG=-fPIC], [PICFLAG=])
5702 AC_SUBST(enable_host_shared)
5706 AC_ARG_ENABLE(libquadmath-support,
5707 [AS_HELP_STRING([--disable-libquadmath-support],
5708 [disable libquadmath support for Fortran])],
5709 ENABLE_LIBQUADMATH_SUPPORT=$enableval,
5710 ENABLE_LIBQUADMATH_SUPPORT=yes)
5711 if test "${ENABLE_LIBQUADMATH_SUPPORT}" != "no" ; then
5712 AC_DEFINE(ENABLE_LIBQUADMATH_SUPPORT, 1,
5713 [Define to 1 to enable libquadmath support])
5717 # Specify what hash style to use by default.
5718 AC_ARG_WITH([linker-hash-style],
5719 [AC_HELP_STRING([--with-linker-hash-style={sysv,gnu,both}],
5720 [specify the linker hash style])],
5721 [case x"$withval" in
5723 LINKER_HASH_STYLE=sysv
5726 LINKER_HASH_STYLE=gnu
5729 LINKER_HASH_STYLE=both
5732 AC_MSG_ERROR([$withval is an invalid option to --with-linker-hash-style])
5735 [LINKER_HASH_STYLE=''])
5736 if test x"${LINKER_HASH_STYLE}" != x; then
5737 AC_DEFINE_UNQUOTED(LINKER_HASH_STYLE, "$LINKER_HASH_STYLE",
5738 [The linker hash style])
5741 # Configure the subdirectories
5742 # AC_CONFIG_SUBDIRS($subdirs)
5744 # Create the Makefile
5745 # and configure language subdirectories
5746 AC_CONFIG_FILES($all_outputs)
5748 AC_CONFIG_COMMANDS([default],
5750 case ${CONFIG_HEADERS} in
5751 *auto-host.h:config.in*)
5754 # Make sure all the subdirs exist.
5755 for d in $subdirs doc build common c-family
5757 test -d $d || mkdir $d
5760 [subdirs='$subdirs'])