2 # Process this file with autoconf to generate a configuration script.
4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003
5 # Free Software Foundation, Inc.
7 #This file is part of GCC.
9 #GCC is free software; you can redistribute it and/or modify it under
10 #the terms of the GNU General Public License as published by the Free
11 #Software Foundation; either version 2, or (at your option) any later
14 #GCC is distributed in the hope that it will be useful, but WITHOUT
15 #ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 #FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 #You should have received a copy of the GNU General Public License
20 #along with GCC; see the file COPYING. If not, write to the Free
21 #Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 # --------------------------------
25 # Initialization and sanity checks
26 # --------------------------------
30 AC_CONFIG_HEADER(auto-host.h:config.in)
32 # Determine the host, build, and target systems
35 # Determine the noncanonical target name, for directory use.
36 _GCC_TOPLEV_NONCANONICAL_TARGET
38 # Determine the target- and build-specific subdirectories
41 # Set program_transform_name
44 # Check for bogus environment variables.
45 # Test if LIBRARY_PATH contains the notation for the current directory
46 # since this would lead to problems installing/building glibc.
47 # LIBRARY_PATH contains the current directory if one of the following
49 # - one of the terminals (":" and ";") is the first or last sign
50 # - two terminals occur directly after each other
51 # - the path contains an element with a dot in it
52 AC_MSG_CHECKING(LIBRARY_PATH variable)
54 case ${LIBRARY_PATH} in
55 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
56 library_path_setting="contains current directory"
59 library_path_setting="ok"
63 AC_MSG_RESULT($library_path_setting)
64 if test "$library_path_setting" != "ok"; then
66 *** LIBRARY_PATH shouldn't contain the current directory when
67 *** building gcc. Please change the environment variable
68 *** and run configure again.])
71 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
72 # since this would lead to problems installing/building glibc.
73 # GCC_EXEC_PREFIX contains the current directory if one of the following
75 # - one of the terminals (":" and ";") is the first or last sign
76 # - two terminals occur directly after each other
77 # - the path contains an element with a dot in it
78 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
80 case ${GCC_EXEC_PREFIX} in
81 [:\;]* | *[:\;] | *[:\;][:\;]* | *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
82 gcc_exec_prefix_setting="contains current directory"
85 gcc_exec_prefix_setting="ok"
89 AC_MSG_RESULT($gcc_exec_prefix_setting)
90 if test "$gcc_exec_prefix_setting" != "ok"; then
92 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
93 *** building gcc. Please change the environment variable
94 *** and run configure again.])
101 # Specify the local prefix
103 AC_ARG_WITH(local-prefix,
104 [ --with-local-prefix=DIR specifies directory to put local include],
105 [case "${withval}" in
106 yes) AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
108 *) local_prefix=$with_local_prefix ;;
111 # Default local prefix if it is empty
112 if test x$local_prefix = x; then
113 local_prefix=/usr/local
116 # Don't set gcc_gxx_include_dir to gxx_include_dir since that's only
117 # passed in by the toplevel make and thus we'd get different behavior
118 # depending on where we built the sources.
120 # Specify the g++ header file directory
121 AC_ARG_WITH(gxx-include-dir,
122 [ --with-gxx-include-dir=DIR
123 specifies directory to put g++ header files],
124 [case "${withval}" in
125 yes) AC_MSG_ERROR(bad value ${withval} given for g++ include directory) ;;
127 *) gcc_gxx_include_dir=$with_gxx_include_dir ;;
130 if test x${gcc_gxx_include_dir} = x; then
131 if test x${enable_version_specific_runtime_libs} = xyes; then
132 gcc_gxx_include_dir='${libsubdir}/include/c++'
134 topsrcdir=${srcdir}/.. . ${srcdir}/../config.if
135 changequote(<<, >>)dnl
136 gcc_gxx_include_dir="\$(libsubdir)/\$(unlibsubdir)/..\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/[^/]*|/..|g'\`/include/"${libstdcxx_incdir}
141 AC_ARG_WITH(cpp_install_dir,
142 [ --with-cpp-install-dir=DIR
143 install the user visible C preprocessor in DIR
144 (relative to PREFIX) as well as PREFIX/bin],
145 [if test x$withval = xyes; then
146 AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
147 elif test x$withval != xno; then
148 cpp_install_dir=$withval
151 # We would like to our source tree to be readonly. However when releases or
152 # pre-releases are generated, the flex/bison generated files as well as the
153 # various formats of manuals need to be included along with the rest of the
154 # sources. Therefore we have --enable-generated-files-in-srcdir to do
157 AC_ARG_ENABLE(generated-files-in-srcdir,
158 [ --enable-generated-files-in-srcdir Put generated files in source dir],
159 [case ${enableval} in
160 no) parsedir='$(objdir)'; docobjdir='$(objdir)/doc';;
161 *) parsedir='$(srcdir)'; docobjdir='$(srcdir)/doc';;
163 [parsedir='$(objdir)'; docobjdir='$(objdir)/doc';])
165 # -------------------
166 # Find default linker
167 # -------------------
171 [ --with-gnu-ld arrange to work with GNU ld.],
172 gnu_ld_flag="$with_gnu_ld",
175 # With pre-defined ld
177 [ --with-ld arrange to use the specified ld (full pathname)],
178 DEFAULT_LINKER="$with_ld")
179 if test x"${DEFAULT_LINKER+set}" = x"set"; then
180 if test ! -x "$DEFAULT_LINKER"; then
181 AC_MSG_WARN([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
182 elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
185 AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
186 [Define to enable the use of a default linker.])
189 AC_MSG_CHECKING([whether a default linker was specified])
190 if test x"${DEFAULT_LINKER+set}" = x"set"; then
191 if test x"$gnu_ld_flag" = x"no"; then
192 AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
194 AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
200 # ----------------------
201 # Find default assembler
202 # ----------------------
206 [ --with-gnu-as arrange to work with GNU as],
207 gas_flag="$with_gnu_as",
211 [ --with-as arrange to use the specified as (full pathname)],
212 DEFAULT_ASSEMBLER="$with_as")
213 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
214 if test ! -x "$DEFAULT_ASSEMBLER"; then
215 AC_MSG_WARN([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
216 elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
219 AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
220 [Define to enable the use of a default assembler.])
223 AC_MSG_CHECKING([whether a default assembler was specified])
224 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
225 if test x"$gas_flag" = x"no"; then
226 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
228 AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
238 # Find the native compiler
241 # autoconf is lame and doesn't give us any substitution variable for this.
242 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
243 NO_MINUS_C_MINUS_O=yes
245 OUTPUT_OPTION='-o $@'
247 AC_SUBST(NO_MINUS_C_MINUS_O)
248 AC_SUBST(OUTPUT_OPTION)
250 # -------------------------
251 # Check C compiler features
252 # -------------------------
254 AC_CACHE_CHECK(whether ${CC-cc} accepts -Wno-long-long,
255 ac_cv_prog_cc_no_long_long,
256 [save_CFLAGS="$CFLAGS"
257 CFLAGS="-Wno-long-long"
258 AC_TRY_COMPILE(,,ac_cv_prog_cc_no_long_long=yes,
259 ac_cv_prog_cc_no_long_long=no)
260 CFLAGS="$save_CFLAGS"])
268 # sizeof(char) is 1 by definition.
269 AC_COMPILE_CHECK_SIZEOF(void *)
270 AC_COMPILE_CHECK_SIZEOF(short)
271 AC_COMPILE_CHECK_SIZEOF(int)
272 AC_COMPILE_CHECK_SIZEOF(long)
273 if test $ac_cv_c_long_long = yes; then
274 AC_COMPILE_CHECK_SIZEOF(long long)
276 if test $ac_cv_c___int64 = yes; then
277 AC_COMPILE_CHECK_SIZEOF(__int64)
284 # See if GNAT has been installed
287 # ---------------------
288 # Warnings and checking
289 # ---------------------
292 if test $ac_cv_prog_cc_no_long_long = yes ; then
293 strict1_warn="-pedantic -Wno-long-long"
295 AC_SUBST(strict1_warn)
297 # If the native compiler is GCC, we can enable warnings even in stage1.
298 # That's useful for people building cross-compilers, or just running a
301 if test "x$GCC" = "xyes"; then
302 warn_cflags='$(GCC_WARN_CFLAGS)'
304 AC_SUBST(warn_cflags)
306 # Enable -Werror in bootstrap stage2 and later.
307 # Change the default to "no" on release branches.
308 AC_ARG_ENABLE(werror,
309 [ --enable-werror enable -Werror in bootstrap stage2 and later], [],
311 if test x$enable_werror = xyes ; then
316 # Enable expensive internal checks
317 AC_ARG_ENABLE(checking,
318 [ --enable-checking[=LIST]
319 enable expensive run-time checks. With LIST,
320 enable only specific categories of checks.
321 Categories are: misc,tree,rtl,rtlflag,gc,gcac,fold;
322 default is misc,tree,gc,rtlflag],
328 ac_gc_always_collect=
330 case "${enableval}" in
331 yes) ac_checking=1 ; ac_tree_checking=1 ; ac_gc_checking=1 ;
332 ac_rtlflag_checking=1 ;;
334 *) IFS="${IFS= }"; ac_save_IFS="$IFS"; IFS="$IFS,"
335 set fnord $enableval; shift
340 misc) ac_checking=1 ;;
341 tree) ac_tree_checking=1 ;;
342 rtlflag) ac_rtlflag_checking=1 ;;
343 rtl) ac_rtl_checking=1 ;;
344 gc) ac_gc_checking=1 ;;
345 gcac) ac_gc_always_collect=1 ;;
346 fold) ac_fold_checking=1 ;;
347 valgrind) ac_checking_valgrind=1 ;;
348 *) AC_MSG_ERROR(unknown check category $check) ;;
354 # Enable some checks by default for development versions of GCC
355 [ac_checking=1; ac_tree_checking=1; ac_gc_checking=1; ac_rtlflag_checking=1;])
357 if test x$ac_checking != x ; then
358 AC_DEFINE(ENABLE_CHECKING, 1,
359 [Define if you want more run-time sanity checks. This one gets a grab
360 bag of miscellaneous but relatively cheap checks.])
361 nocommon_flag=-fno-common
363 AC_SUBST(nocommon_flag)
364 if test x$ac_tree_checking != x ; then
365 AC_DEFINE(ENABLE_TREE_CHECKING, 1,
366 [Define if you want all operations on trees (the basic data
367 structure of the front ends) to be checked for dynamic type safety
368 at runtime. This is moderately expensive.])
370 if test x$ac_rtl_checking != x ; then
371 AC_DEFINE(ENABLE_RTL_CHECKING, 1,
372 [Define if you want all operations on RTL (the basic data structure
373 of the optimizer and back end) to be checked for dynamic type safety
374 at runtime. This is quite expensive.])
376 if test x$ac_rtlflag_checking != x ; then
377 AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
378 [Define if you want RTL flag accesses to be checked against the RTL
379 codes that are supported for each access macro. This is relatively
382 if test x$ac_gc_checking != x ; then
383 AC_DEFINE(ENABLE_GC_CHECKING, 1,
384 [Define if you want the garbage collector to do object poisoning and
385 other memory allocation checks. This is quite expensive.])
387 if test x$ac_gc_always_collect != x ; then
388 AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
389 [Define if you want the garbage collector to operate in maximally
390 paranoid mode, validating the entire heap and collecting garbage at
391 every opportunity. This is extremely expensive.])
393 if test x$ac_fold_checking != x ; then
394 AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
395 [Define if you want fold checked that it never destructs its argument.
396 This is quite expensive.])
398 valgrind_path_defines=
401 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
402 dnl # an if statement. This was the source of very frustrating bugs
403 dnl # in converting to autoconf 2.5x!
404 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
406 if test x$ac_checking_valgrind != x ; then
407 # It is certainly possible that there's valgrind but no valgrind.h.
408 # GCC relies on making annotations so we must have both.
409 AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
411 [#include <valgrind/memcheck.h>
412 #ifndef VALGRIND_DISCARD
413 #error VALGRIND_DISCARD not defined
415 [gcc_cv_header_valgrind_memcheck_h=yes],
416 [gcc_cv_header_valgrind_memcheck_h=no])
417 AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
418 AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
420 [#include <memcheck.h>
421 #ifndef VALGRIND_DISCARD
422 #error VALGRIND_DISCARD not defined
424 [gcc_cv_header_memcheck_h=yes],
425 gcc_cv_header_memcheck_h=no)
426 AC_MSG_RESULT($gcc_cv_header_memcheck_h)
427 AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
428 [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
429 if test "x$valgrind_path" = "x" \
430 || (test $have_valgrind_h = no \
431 && test $gcc_cv_header_memcheck_h = no \
432 && test $gcc_cv_header_valgrind_memcheck_h = no); then
433 AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
435 valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
436 valgrind_command="$valgrind_path -q"
437 AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
438 [Define if you want to run subprograms and generated programs
439 through valgrind (a memory checker). This is extremely expensive.])
440 if test $gcc_cv_header_valgrind_memcheck_h = yes; then
441 AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
442 [Define if valgrind's valgrind/memcheck.h header is installed.])
444 if test $gcc_cv_header_memcheck_h = yes; then
445 AC_DEFINE(HAVE_MEMCHECK_H, 1,
446 [Define if valgrind's memcheck.h header is installed.])
449 AC_SUBST(valgrind_path_defines)
450 AC_SUBST(valgrind_command)
452 # Enable code coverage collection
453 AC_ARG_ENABLE(coverage,
454 [ --enable-coverage[=LEVEL]
455 enable compiler\'s code coverage collection.
456 Use to measure compiler performance and locate
457 unused parts of the compiler. With LEVEL, specify
458 optimization. Values are opt, noopt,
460 [case "${enableval}" in
462 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
465 coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
468 AC_MSG_ERROR(unknown coverage setting $enableval)
472 AC_SUBST(coverage_flags)
474 # -------------------------------
475 # Miscenalleous configure options
476 # -------------------------------
480 [ --with-stabs arrange to use stabs instead of host debug format],
484 # Determine whether or not multilibs are enabled.
485 AC_ARG_ENABLE(multilib,
486 [ --enable-multilib enable library support for multiple ABIs],
487 [], [enable_multilib=yes])
488 AC_SUBST(enable_multilib)
490 # Enable __cxa_atexit for C++.
491 AC_ARG_ENABLE(__cxa_atexit,
492 [ --enable-__cxa_atexit enable __cxa_atexit for C++],
496 # Pass with no value to take the default
497 # Pass with a value to specify a thread package
498 AC_ARG_ENABLE(threads,
499 [ --enable-threads enable thread usage for target GCC
500 --enable-threads=LIB use LIB thread package for target GCC],,
502 # Save in case it gets overwritten in config.gcc
503 enable_threads_flag=$enable_threads
505 AC_ARG_ENABLE(objc-gc,
506 [ --enable-objc-gc enable the use of Boehm's garbage collector with
507 the GNU Objective-C runtime],
508 if test x$enable_objc_gc = xno; then
516 [ --with-dwarf2 force the default debug format to be DWARF 2],
517 dwarf2="$with_dwarf2",
520 AC_ARG_ENABLE(shared,
521 [ --disable-shared don't provide a shared libgcc],
523 case $enable_shared in
527 IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
528 for pkg in $enableval; do
529 if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
536 ], [enable_shared=yes])
537 AC_SUBST(enable_shared)
540 [ --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
542 case ${with_sysroot} in
543 yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
544 *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
547 TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
548 CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)'
550 if test "x$exec_prefix" = xNONE; then
551 if test "x$prefix" = xNONE; then
552 test_prefix=/usr/local
557 test_prefix=$exec_prefix
559 case ${TARGET_SYSTEM_ROOT} in
560 "${test_prefix}"|"${test_prefix}/"*|\
561 '${exec_prefix}'|'${exec_prefix}/'*)
562 t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
563 TARGET_SYSTEM_ROOT_DEFINE="$t"
568 TARGET_SYSTEM_ROOT_DEFINE=
569 CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
571 AC_SUBST(TARGET_SYSTEM_ROOT)
572 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
573 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
575 # Build with intermodule optimisations
576 AC_ARG_ENABLE(intermodule,
577 [ --enable-intermodule build the compiler in one step],
578 [case ${enable_intermodule} in
579 yes) onestep="-onestep";;
585 # -------------------------
586 # Checks for other programs
587 # -------------------------
591 # Find some useful tools
593 # We need awk to run opts.sh (to create options.c and options.h).
594 # Bail out if it's missing.
596 "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
604 # See if cmp has --ignore-initial.
605 gcc_AC_PROG_CMP_IGNORE_INITIAL
607 # See if we have the mktemp command.
608 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
610 # Do we have a single-tree copy of texinfo?
611 if test -f $srcdir/../texinfo/Makefile.in; then
612 MAKEINFO='$(objdir)/../texinfo/makeinfo/makeinfo'
613 gcc_cv_prog_makeinfo_modern=yes
614 AC_MSG_RESULT([Using makeinfo from the unified source tree.])
616 # See if makeinfo has been installed and is modern enough
617 # that we can use it.
618 gcc_AC_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
619 [GNU texinfo.* \([0-9][0-9.]*\)],
623 if test $gcc_cv_prog_makeinfo_modern = no; then
625 *** Makeinfo is missing or too old.
626 *** Info documentation will not be built.])
629 BUILD_INFO=info AC_SUBST(BUILD_INFO)
632 # Is pod2man recent enough to regenerate manpages?
633 AC_MSG_CHECKING([for recent Pod::Man])
634 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
636 GENERATED_MANPAGES=generated-manpages AC_SUBST(GENERATED_MANPAGES)
643 dnl Don't use AC_PROG_LEX; we insist on flex.
644 dnl LEXLIB is not useful in gcc.
645 if test -f $srcdir/../flex/skel.c; then
646 FLEX='$(objdir)/../flex/flex'
648 AC_CHECK_PROG(FLEX, flex, flex, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing flex)
652 # The -L switch is so bison can find its skeleton file.
653 if test -f $srcdir/../bison/bison.simple; then
654 BISON='$(objdir)/../bison/bison -L $(srcdir)/../bison/'
656 AC_CHECK_PROG(BISON, bison, bison, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing bison)
659 # --------------------
660 # Checks for C headers
661 # --------------------
663 AC_MSG_CHECKING(for GNU C library)
664 AC_CACHE_VAL(gcc_cv_glibc,
666 [#include <features.h>],[
667 #if ! (defined __GLIBC__ || defined __GNU_LIBRARY__)
668 #error Not a GNU C library system
672 AC_MSG_RESULT($gcc_cv_glibc)
673 if test $gcc_cv_glibc = yes; then
674 AC_DEFINE(_GNU_SOURCE, 1, [Always define this when using the GNU C Library])
679 gcc_AC_HEADER_STDBOOL
682 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h \
683 fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
684 sys/resource.h sys/param.h sys/times.h sys/stat.h \
685 direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
687 # Check for thread headers.
688 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
689 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
691 # These tests can't be done till we know if we have limits.h.
699 # Stage specific cflags for build.
705 stage1_cflags="-Wa,-J"
711 # The spiffy cpp-precomp chokes on some legitimate constructs in GCC
712 # sources; use -no-cpp-precomp to get to GNU cpp.
713 # Apple's GCC has bugs in designated initializer handling, so disable
715 stage1_cflags="-no-cpp-precomp -DHAVE_DESIGNATED_INITIALIZERS=0"
718 AC_SUBST(stage1_cflags)
720 # These libraries may be used by collect2.
721 # We may need a special search path to get them linked.
722 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
724 for libs in '' -lld -lmld \
725 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
726 '-L/usr/lib/cmplrs/cc3.11 -lmld'
729 AC_TRY_LINK_FUNC(ldopen,
730 [gcc_cv_collect2_libs="$libs"; break])
733 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
734 case $gcc_cv_collect2_libs in
736 *) COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
738 AC_SUBST(COLLECT2_LIBS)
740 # When building Ada code on Alpha, we need exc_resume which is usually in
741 # -lexc. So test for it.
744 AC_SEARCH_LIBS(exc_resume, exc)
747 AC_SUBST(GNAT_LIBEXC)
749 # Some systems put ldexp and frexp in libm instead of libc; assume
750 # they're both in the same place. jcf-dump needs them.
753 AC_SEARCH_LIBS(ldexp, m)
758 # Use <inttypes.h> only if it exists,
759 # doesn't clash with <sys/types.h>, and declares intmax_t.
760 AC_MSG_CHECKING(for inttypes.h)
761 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
763 [#include <sys/types.h>
764 #include <inttypes.h>],
766 [gcc_cv_header_inttypes_h=yes],
767 gcc_cv_header_inttypes_h=no)])
768 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
769 if test $gcc_cv_header_inttypes_h = yes; then
770 AC_DEFINE(HAVE_INTTYPES_H, 1,
771 [Define if you have a working <inttypes.h> header file.])
774 dnl Disabled until we have a complete test for buggy enum bitfields.
775 dnl gcc_AC_C_ENUM_BF_UNSIGNED
777 AC_CHECK_FUNCS(times clock dup2 kill getrlimit setrlimit atoll atoq \
778 sysconf strsignal putc_unlocked fputc_unlocked fputs_unlocked \
779 fwrite_unlocked fprintf_unlocked getrusage nl_langinfo \
780 scandir alphasort gettimeofday mbstowcs wcswidth mmap mincore \
783 if test x$ac_cv_func_mbstowcs = xyes; then
784 AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
785 [ AC_TRY_RUN([#include <stdlib.h>
791 gcc_cv_func_mbstowcs_works=yes,
792 gcc_cv_func_mbstowcs_works=no,
793 gcc_cv_func_mbstowcs_works=yes)])
794 if test x$gcc_cv_func_mbstowcs_works = xyes; then
795 AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
796 [Define this macro if mbstowcs does not crash when its
797 first argument is NULL.])
801 gcc_AC_CHECK_TYPE(ssize_t, int)
803 # Try to determine the array type of the second argument of getgroups
804 # for the target system (int or gid_t).
806 if test "${target}" = "${build}"; then
807 TARGET_GETGROUPS_T=$ac_cv_type_getgroups
810 # This condition may need some tweaking. It should include all
811 # targets where the array type of the second argument of getgroups
812 # is int and the type of gid_t is not equivalent to int.
813 *-*-sunos* | *-*-ultrix*)
814 TARGET_GETGROUPS_T=int
817 TARGET_GETGROUPS_T=gid_t
821 AC_SUBST(TARGET_GETGROUPS_T)
823 gcc_AC_FUNC_PRINTF_PTR
824 gcc_AC_FUNC_MMAP_BLACKLIST
828 # Under VMS, vfork works very differently than on Unix. The standard test
829 # won't work, and it isn't easily adaptable. It makes more sense to
831 ac_cv_func_vfork_works=yes
837 # Until we have in-tree GNU iconv:
839 AC_SUBST(LIBICONV_DEP)
843 # We will need to find libiberty.h and ansidecl.h
844 saved_CFLAGS="$CFLAGS"
845 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
846 gcc_AC_CHECK_DECLS(getenv atol sbrk abort atof getcwd getwd \
847 strsignal putc_unlocked fputs_unlocked fwrite_unlocked \
848 fprintf_unlocked strstr errno snprintf vasprintf \
849 malloc realloc calloc free basename getopt clock, , ,[
850 #include "ansidecl.h"
851 #include "system.h"])
853 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
854 #include "ansidecl.h"
856 #ifdef HAVE_SYS_RESOURCE_H
857 #include <sys/resource.h>
862 #include "ansidecl.h"
864 #ifdef HAVE_SYS_RESOURCE_H
865 #include <sys/resource.h>
867 ],[rlim_t l = 0;],,[AC_DEFINE([rlim_t],[long],
868 [Define to \`long' if <sys/resource.h> doesn't define.])])
870 gcc_AC_CHECK_DECLS(ldgetname, , ,[
871 #include "ansidecl.h"
878 gcc_AC_CHECK_DECLS(times, , ,[
879 #include "ansidecl.h"
881 #ifdef HAVE_SYS_TIMES_H
882 #include <sys/times.h>
886 # More time-related stuff.
887 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
889 #include "ansidecl.h"
891 #ifdef HAVE_SYS_TIMES_H
892 #include <sys/times.h>
894 ], [struct tms tms;], ac_cv_struct_tms=yes, ac_cv_struct_tms=no)])
895 if test $ac_cv_struct_tms = yes; then
896 AC_DEFINE(HAVE_STRUCT_TMS, 1,
897 [Define if <sys/times.h> defines struct tms.])
900 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
901 # revisit after autoconf 2.50.
902 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
904 #include "ansidecl.h"
906 ], [clock_t x;], gcc_cv_type_clock_t=yes, gcc_cv_type_clock_t=no)])
907 if test $gcc_cv_type_clock_t = yes; then
908 AC_DEFINE(HAVE_CLOCK_T, 1,
909 [Define if <time.h> defines clock_t.])
912 AC_CACHE_CHECK(for uchar, gcc_cv_type_uchar,
914 #include "ansidecl.h"
917 [if ((uchar *)0) return 0;
918 if (sizeof(uchar)) return 0;],
919 ac_cv_type_uchar=yes, ac_cv_type_uchar=no)])
920 if test $ac_cv_type_uchar = yes; then
921 AC_DEFINE(HAVE_UCHAR, 1,
922 [Define if <sys/types.h> defines \`uchar'.])
925 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
926 CFLAGS="$saved_CFLAGS"
928 gcc_AC_INITFINI_ARRAY
930 # mkdir takes a single argument on some systems.
931 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
939 # With Setjmp/Longjmp based exception handling.
940 AC_ARG_ENABLE(sjlj-exceptions,
941 [ --enable-sjlj-exceptions
942 arrange to use setjmp/longjmp exception handling],
943 [sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
944 AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
945 [Define 0/1 to force the choice for exception handling model.])])
947 if test x$host = x$target; then
948 AC_CHECK_LIB(unwind, main, use_libunwind_default=yes, use_libunwind_default=no)
950 use_libunwind_default=no
952 # Use libunwind based exception handling.
953 AC_ARG_ENABLE(libunwind-exceptions,
954 [ --enable-libunwind-exceptions force use libunwind for exceptions],
955 use_libunwind_exceptions=$enableval,
956 use_libunwind_exceptions=$use_libunwind_default)
957 if test x"$use_libunwind_exceptions" = xyes; then
958 AC_DEFINE(USE_LIBUNWIND_EXCEPTIONS, 1,
959 [Define if gcc should use -lunwind.])
960 AC_CHECK_LIB(unwind, _Unwind_Resume, libunwind_has_eh_support=yes,
961 libunwind_has_eh_support=no)
964 # --------------------------------------------------------
965 # Build, host, and target specific configuration fragments
966 # --------------------------------------------------------
968 # Collect build-machine-specific information.
969 . ${srcdir}/config.build
971 # Collect host-machine-specific information.
972 . ${srcdir}/config.host
976 # Collect target-machine-specific information.
977 . ${srcdir}/config.gcc
979 extra_objs="${host_extra_objs} ${extra_objs}"
981 # Default the target-machine variables that were not explicitly set.
982 if test x"$tm_file" = x
983 then tm_file=$cpu_type/$cpu_type.h; fi
985 if test x"$extra_headers" = x
986 then extra_headers=; fi
988 if test x$md_file = x
989 then md_file=$cpu_type/$cpu_type.md; fi
991 if test x$out_file = x
992 then out_file=$cpu_type/$cpu_type.c; fi
994 if test x"$tmake_file" = x
995 then tmake_file=$cpu_type/t-$cpu_type
998 if test x"$dwarf2" = xyes
999 then tm_file="$tm_file tm-dwarf2.h"
1002 # Say what files are being used for the output code and MD file.
1003 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1004 echo "Using \`$srcdir/config/$md_file' as machine description file."
1006 # If any of the xm_file variables contain nonexistent files, warn
1007 # about them and drop them.
1010 for x in $build_xm_file; do
1011 if test -f $srcdir/config/$x
1013 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1019 for x in $host_xm_file; do
1020 if test -f $srcdir/config/$x
1022 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1028 for x in $xm_file; do
1029 if test -f $srcdir/config/$x
1031 else AC_MSG_WARN($srcdir/config/$x does not exist.)
1037 for f in $tm_file; do
1040 if test $count = ax; then
1041 echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1043 echo "Using the following target machine macro files:"
1044 for f in $tm_file; do
1045 echo " $srcdir/config/$f"
1049 if test x$need_64bit_hwint = xyes; then
1050 AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1051 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1055 for f in $host_xm_file; do
1058 if test $count = a; then
1060 elif test $count = ax; then
1061 echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1063 echo "Using the following host machine macro files:"
1064 for f in $host_xm_file; do
1065 echo " $srcdir/config/$f"
1068 echo "Using ${out_host_hook_obj} for host machine hooks."
1070 if test "$host_xm_file" != "$build_xm_file"; then
1072 for f in $build_xm_file; do
1075 if test $count = a; then
1077 elif test $count = ax; then
1078 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1080 echo "Using the following build machine macro files:"
1081 for f in $build_xm_file; do
1082 echo " $srcdir/config/$f"
1087 # Check if a valid thread package
1088 case ${enable_threads_flag} in
1091 target_thread_file='single'
1095 target_thread_file='single'
1097 aix | dce | gnat | irix | posix | rtems | \
1098 single | solaris | vxworks | win32 )
1099 target_thread_file=${enable_threads_flag}
1102 echo "${enable_threads_flag} is an unknown thread package" 1>&2
1107 if test x${thread_file} = x; then
1108 # No thread file set by target-specific clauses in config.gcc,
1109 # so use file chosen by default logic above
1110 thread_file=${target_thread_file}
1113 if test x$enable___cxa_atexit = xyes || \
1114 test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1115 AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 1,
1116 [Define if you want to use __cxa_atexit, rather than atexit, to
1117 register C++ destructors for local statics and global objects.
1118 This is essential for fully standards-compliant handling of
1119 destructors, but requires __cxa_atexit in libc.])
1122 # Look for a file containing extra machine modes.
1123 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1124 extra_modes_file='$(srcdir)'/config/${extra_modes}
1125 AC_SUBST(extra_modes_file)
1126 AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1127 [Define to the name of a file containing a list of extra machine modes
1128 for this architecture.])
1131 # auto-host.h is the file containing items generated by autoconf and is
1132 # the first file included by config.h.
1133 # If host=build, it is correct to have bconfig include auto-host.h
1134 # as well. If host!=build, we are in error and need to do more
1135 # work to find out the build config parameters.
1136 if test x$host = x$build
1138 build_auto=auto-host.h
1141 # We create a subdir, then run autoconf in the subdir.
1142 # To prevent recursion we set host and build for the new
1143 # invocation of configure to the build for this invocation
1150 /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1151 *) realsrcdir=../${srcdir};;
1153 saved_CFLAGS="${CFLAGS}"
1154 CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1155 ${realsrcdir}/configure \
1156 --target=$target_alias --host=$build_alias --build=$build_alias
1157 CFLAGS="${saved_CFLAGS}"
1159 # We just finished tests for the build machine, so rename
1160 # the file auto-build.h in the gcc directory.
1161 mv auto-host.h ../auto-build.h
1164 build_auto=auto-build.h
1165 FORBUILD=../${build_subdir}
1169 tm_file="${tm_file} defaults.h"
1170 tm_p_file="${tm_p_file} tm-preds.h"
1171 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1172 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1173 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1174 # put this back in temporarily.
1175 xm_file="ansidecl.h ${xm_file}"
1181 # Get the version trigger filename from the toplevel
1182 if test "${with_gcc_version_trigger+set}" = set; then
1183 gcc_version_trigger=$with_gcc_version_trigger
1185 gcc_version_trigger=${srcdir}/version.c
1188 gcc_version_full=`grep version_string ${gcc_version_trigger} | sed -e 's/.*"\([^"]*\)".*/\1/'`
1189 gcc_version=`echo ${gcc_version_full} | sed -e 's/\([^ ]*\) .*/\1/'`
1191 # Compile in configure arguments.
1192 if test -f configargs.h ; then
1193 # Being re-configured.
1194 gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1195 gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1197 gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1200 # Double all backslashes and backslash all quotes to turn
1201 # gcc_config_arguments into a C string.
1202 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1203 $gcc_config_arguments
1205 gcc_config_arguments_str=`cat conftest.out`
1208 cat > configargs.h <<EOF
1209 /* Generated automatically. */
1210 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1211 static const char thread_model[] = "$thread_file";
1213 static const struct {
1214 const char *name, *value;
1215 } configure_default_options[] = $configure_default_options;
1219 # Internationalization
1221 VERSION="$gcc_version"
1225 ZW_GNU_GETTEXT_SISTER_DIR
1227 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1228 # -liconv on the link line twice.
1229 case "$LIBINTL" in *$LIBICONV*)
1233 # Windows32 Registry support for specifying GCC installation paths.
1234 AC_ARG_ENABLE(win32-registry,
1235 [ --disable-win32-registry
1236 disable lookup of installation paths in the
1237 Registry on Windows hosts
1238 --enable-win32-registry enable registry lookup (default)
1239 --enable-win32-registry=KEY
1240 use KEY instead of GCC version as the last portion
1241 of the registry key],,)
1243 win32 | pe | cygwin* | mingw32* | uwin*)
1244 AC_MSG_CHECKING(whether windows registry support is requested)
1245 if test "x$enable_win32_registry" != xno; then
1246 AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1247 [Define to 1 if installation paths should be looked up in Windows32
1248 Registry. Ignored on non windows32 hosts.])
1250 AC_SEARCH_LIBS(RegOpenKeyExA, advapi32)
1255 # Check if user specified a different registry key.
1256 case "x${enable_win32_registry}" in
1259 gcc_cv_win32_registry_key="$VERSION"
1262 # no registry lookup.
1263 gcc_cv_win32_registry_key=''
1266 # user-specified key.
1267 gcc_cv_win32_registry_key="$enable_win32_registry"
1271 if test "x$enable_win32_registry" != xno; then
1272 AC_MSG_CHECKING(registry key on windows hosts)
1273 AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$gcc_cv_win32_registry_key",
1274 [Define to be the last portion of registry key on windows hosts.])
1275 AC_MSG_RESULT($gcc_cv_win32_registry_key)
1280 # Get an absolute path to the GCC top-level source directory
1281 holddir=`${PWDCMD-pwd}`
1283 topdir=`${PWDCMD-pwd}`
1286 # Conditionalize the makefile for this host machine.
1288 for f in ${host_xmake_file}
1290 if test -f ${srcdir}/config/$f
1292 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1296 # Conditionalize the makefile for this target machine.
1298 for f in ${tmake_file}
1300 if test -f ${srcdir}/config/$f
1302 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1305 tmake_file="${tmake_file_}"
1307 symbolic_link='ln -s'
1309 # If the host doesn't support symlinks, modify CC in
1310 # FLAGS_TO_PASS so CC="stage1/xgcc -Bstage1/" works.
1311 # Otherwise, we can use "CC=$(CC)".
1313 if $symbolic_link $srcdir/gcc.c symtest.tem 2>/dev/null
1315 cc_set_by_configure="\$(CC)"
1316 quoted_cc_set_by_configure="\$(CC)"
1317 stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1318 quoted_stage_prefix_set_by_configure="\$(STAGE_PREFIX)"
1321 if cp -p $srcdir/gcc.c symtest.tem 2>/dev/null
1323 symbolic_link="cp -p"
1327 cc_set_by_configure="\`case '\$(CC)' in stage*) echo '\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\$(CC)';; esac\`"
1328 quoted_cc_set_by_configure="\\\`case '\\\$(CC)' in stage*) echo '\\\$(CC)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(CC)';; esac\\\`"
1329 stage_prefix_set_by_configure="\`case '\$(STAGE_PREFIX)' in stage*) echo '\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\$(STAGE_PREFIX)';; esac\`"
1330 quoted_stage_prefix_set_by_configure="\\\`case '\\\$(STAGE_PREFIX)' in stage*) echo '\\\$(STAGE_PREFIX)' | sed -e 's|stage|../stage|g';; *) echo '\\\$(STAGE_PREFIX)';; esac\\\`"
1334 out_object_file=`basename $out_file .c`.o
1338 for f in $tm_file; do
1341 tm_file_list="${tm_file_list} \$(srcdir)/$f"
1342 tm_include_list="${tm_include_list} $f"
1345 tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1346 tm_include_list="${tm_include_list} config/$f"
1353 for f in $tm_p_file; do
1356 tm_p_file_list="${tm_p_file_list} $f"
1357 tm_p_include_list="${tm_p_include_list} $f"
1360 tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1361 tm_p_include_list="${tm_p_include_list} config/$f"
1367 for f in $xm_file; do
1370 xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1371 xm_include_list="${xm_include_list} $f"
1374 xm_file_list="${xm_file_list} $f"
1375 xm_include_list="${xm_include_list} $f"
1378 xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1379 xm_include_list="${xm_include_list} config/$f"
1385 host_xm_include_list=
1386 for f in $host_xm_file; do
1389 host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1390 host_xm_include_list="${host_xm_include_list} $f"
1393 host_xm_file_list="${host_xm_file_list} $f"
1394 host_xm_include_list="${host_xm_include_list} $f"
1397 host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1398 host_xm_include_list="${host_xm_include_list} config/$f"
1404 for f in $build_xm_file; do
1407 build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1408 build_xm_include_list="${build_xm_include_list} $f"
1410 auto-build.h | auto-host.h )
1411 build_xm_file_list="${build_xm_file_list} $f"
1412 build_xm_include_list="${build_xm_include_list} $f"
1415 build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1416 build_xm_include_list="${build_xm_include_list} config/$f"
1421 # Define macro CROSS_COMPILE in compilation if this is a cross-compiler.
1422 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1423 CROSS= AC_SUBST(CROSS)
1424 ALL=all.internal AC_SUBST(ALL)
1425 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1426 if test x$host != x$target
1428 CROSS="-DCROSS_COMPILE"
1430 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1431 case "$host","$target" in
1432 # Darwin crosses can use the host system's libraries and headers,
1433 # because of the fat library support. Of course, it must be the
1434 # same version of Darwin on both sides. Allow the user to
1435 # just say --target=foo-darwin without a version number to mean
1436 # "the version on this system".
1437 *-*-darwin*,*-*-darwin*)
1438 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1439 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1440 if test $hostos = $targetos -o $targetos = darwin ; then
1442 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1447 i?86-*-*,x86_64-*-* \
1448 | powerpc*-*-*,powerpc64*-*-*)
1449 CROSS="$CROSS -DNATIVE_CROSS" ;;
1451 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1452 # This is just $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR)
1453 SYSTEM_HEADER_DIR='$(CROSS_SYSTEM_HEADER_DIR)'
1456 # If this is a cross-compiler that does not
1457 # have its own set of headers then define
1460 # If this is using newlib, without having the headers available now,
1461 # then define inhibit_libc in LIBGCC2_CFLAGS.
1462 # This prevents libgcc2 from containing any code which requires libc
1465 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1466 test x$with_newlib = xyes ; } &&
1467 { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1468 inhibit_libc=-Dinhibit_libc
1470 AC_SUBST(inhibit_libc)
1472 # When building gcc with a cross-compiler, we need to adjust things so
1473 # that the generator programs are still built with the native compiler.
1474 # Also, we cannot run fixincludes or fix-header.
1476 # These are the normal (build=host) settings:
1477 BUILD_PREFIX= AC_SUBST(BUILD_PREFIX)
1478 BUILD_PREFIX_1=ignore- AC_SUBST(BUILD_PREFIX_1)
1479 CC_FOR_BUILD='$(CC)' AC_SUBST(CC_FOR_BUILD)
1480 BUILD_CFLAGS='$(ALL_CFLAGS)' AC_SUBST(BUILD_CFLAGS)
1482 STMP_FIXINC=stmp-fixinc AC_SUBST(STMP_FIXINC)
1484 # Possibly disable fixproto, on a per-target basis.
1485 case ${use_fixproto} in
1490 STMP_FIXPROTO=stmp-fixproto
1493 AC_SUBST(STMP_FIXPROTO)
1495 # And these apply if build != host, or we are generating coverage data
1496 if test x$build != x$host || test "x$coverage_flags" != x
1499 BUILD_PREFIX_1=build-
1500 BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1502 if test "x$TARGET_SYSTEM_ROOT" = x; then
1508 # Expand extra_headers to include complete path.
1509 # This substitutes for lots of t-* files.
1511 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1512 for file in ${extra_headers} ; do
1513 extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1516 # Add a definition of USE_COLLECT2 if system wants one.
1517 case $use_collect2 in
1518 no) use_collect2= ;;
1521 host_xm_defines="${host_xm_defines} USE_COLLECT2"
1522 xm_defines="${xm_defines} USE_COLLECT2"
1526 # Identify the assembler which will work hand-in-glove with the newly
1527 # built GCC, so that we can examine its features. This is the assembler
1528 # which will be driven by the driver program.
1530 # If build != host, and we aren't building gas in-tree, we identify a
1531 # build->target assembler and hope that it will have the same features
1532 # as the host->target assembler we'll be using.
1533 AC_MSG_CHECKING(what assembler to use)
1536 gcc_cv_gas_major_version=
1537 gcc_cv_gas_minor_version=
1538 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1539 if test -x "$DEFAULT_ASSEMBLER"; then
1540 gcc_cv_as="$DEFAULT_ASSEMBLER"
1541 elif test -x "$AS"; then
1543 elif test -x as$host_exeext; then
1544 # Build using assembler in the current directory.
1545 gcc_cv_as=./as$host_exeext
1546 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1547 && test -f ../gas/Makefile; then
1548 # Single tree build which includes gas.
1550 _gcc_COMPUTE_GAS_VERSION
1551 rm -f as$host_exeext
1552 $symbolic_link ../gas/as-new$host_exeext as$host_exeext 2>/dev/null
1553 in_tree_gas_is_elf=no
1554 if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1555 || (grep 'obj_format = multi' ../gas/Makefile \
1556 && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1558 in_tree_gas_is_elf=yes
1562 if test "x$gcc_cv_as" = x; then
1563 # Search the same directories that the installed compiler will
1564 # search. Else we may find the wrong assembler and lose. If we
1565 # do not find a suitable assembler binary, then try the user's
1568 # Also note we have to check MD_EXEC_PREFIX before checking the
1569 # user's path. Unfortunately, there is no good way to get at the
1570 # value of MD_EXEC_PREFIX here. So we do a brute force search
1571 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1572 # to be fixed as part of the make/configure rewrite too.
1574 if test "x$exec_prefix" = xNONE; then
1575 if test "x$prefix" = xNONE; then
1576 test_prefix=/usr/local
1581 test_prefix=$exec_prefix
1584 # If the loop below does not find an assembler, then use whatever
1585 # one we can find in the users's path.
1587 if test "x$program_prefix" != xNONE; then
1588 gcc_cv_as=${program_prefix}as$host_exeext
1590 gcc_cv_as=`echo as | sed ${program_transform_name}`$host_exeext
1593 test_dirs="$test_prefix/lib/gcc-lib/$target_noncanonical/$gcc_version \
1594 $test_prefix/lib/gcc-lib/$target_noncanonical \
1595 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1596 /usr/lib/gcc/$target_noncanonical \
1597 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1598 $test_prefix/$target_noncanonical/bin"
1600 if test x$host = x$target; then
1601 test_dirs="$test_dirs \
1606 /bsd43/usr/lib/cmplrs/cc \
1607 /usr/cross64/usr/bin \
1608 /usr/lib/cmplrs/cc \
1609 /sysv/usr/lib/cmplrs/cc \
1610 /svr4/usr/lib/cmplrs/cc \
1614 for dir in $test_dirs; do
1615 if test -x $dir/as$host_exeext; then
1616 gcc_cv_as=$dir/as$host_exeext
1621 case $in_tree_gas in
1623 AC_MSG_RESULT("newly built gas")
1626 AC_MSG_RESULT($gcc_cv_as)
1630 # Identify the linker which will work hand-in-glove with the newly
1631 # built GCC, so that we can examine its features. This is the linker
1632 # which will be driven by the driver program.
1634 # If build != host, and we aren't building gas in-tree, we identify a
1635 # build->target linker and hope that it will have the same features
1636 # as the host->target linker we'll be using.
1637 AC_MSG_CHECKING(what linker to use)
1640 gcc_cv_gld_major_version=
1641 gcc_cv_gld_minor_version=
1642 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1643 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1644 if test -x "$DEFAULT_LINKER"; then
1645 gcc_cv_ld="$DEFAULT_LINKER"
1646 elif test -x "$LD"; then
1648 elif test -x collect-ld$host_exeext; then
1649 # Build using linker in the current directory.
1650 gcc_cv_ld=./collect-ld$host_exeext
1651 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1652 && test -f ../ld/Makefile; then
1653 # Single tree build which includes ld.
1655 in_tree_ld_is_elf=no
1656 if (grep 'EMUL = .*elf' ../ld/Makefile \
1657 || grep 'EMUL = .*linux' ../ld/Makefile) > /dev/null; then
1658 in_tree_ld_is_elf=yes
1660 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
1663 gcc_cv_gld_version=`grep '^VERSION=[0-9]*\.[0-9]*' $f`
1665 if test x$gcc_cv_gld_version != x; then
1670 gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1671 gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1673 rm -f collect-ld$host_exeext
1674 $symbolic_link ../ld/ld-new$host_exeext collect-ld$host_exeext \
1678 if test "x$gcc_cv_ld" = x; then
1679 # Search the same directories that the installed compiler will
1680 # search. Else we may find the wrong linker and lose. If we
1681 # do not find a suitable linker binary, then try the user's
1684 # Also note we have to check MD_EXEC_PREFIX before checking the
1685 # user's path. Unfortunately, there is no good way to get at the
1686 # value of MD_EXEC_PREFIX here. So we do a brute force search
1687 # through all the known MD_EXEC_PREFIX values. Ugh. This needs
1688 # to be fixed as part of the make/configure rewrite too.
1690 if test "x$exec_prefix" = xNONE; then
1691 if test "x$prefix" = xNONE; then
1692 test_prefix=/usr/local
1697 test_prefix=$exec_prefix
1700 # If the loop below does not find an linker, then use whatever
1701 # one we can find in the users's path.
1703 if test "x$program_prefix" != xNONE; then
1704 gcc_cv_ld=${program_prefix}ld$host_exeext
1706 gcc_cv_ld=`echo ld | sed ${program_transform_name}`$host_exeext
1709 test_dirs="$test_prefix/lib/gcc-lib/$target_noncanonical/$gcc_version \
1710 $test_prefix/lib/gcc-lib/$target_noncanonical \
1711 /usr/lib/gcc/$target_noncanonical/$gcc_version \
1712 /usr/lib/gcc/$target_noncanonical \
1713 $test_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version \
1714 $test_prefix/$target_noncanonical/bin"
1716 if test x$host = x$target; then
1717 test_dirs="$test_dirs \
1722 /bsd43/usr/lib/cmplrs/cc \
1723 /usr/cross64/usr/bin \
1724 /usr/lib/cmplrs/cc \
1725 /sysv/usr/lib/cmplrs/cc \
1726 /svr4/usr/lib/cmplrs/cc \
1730 for dir in $test_dirs; do
1731 if test -x $dir/ld$host_exeext; then
1732 gcc_cv_ld=$dir/ld$host_exeext
1739 AC_MSG_RESULT("newly built ld")
1742 AC_MSG_RESULT($gcc_cv_ld)
1746 # Figure out what nm we will be using.
1747 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1748 AC_MSG_CHECKING(what nm to use)
1750 if test -x nm$host_exeext; then
1751 gcc_cv_nm=./nm$host_exeext
1752 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1753 && test -f ../binutils/Makefile; then
1754 # Single tree build which includes binutils.
1756 gcc_cv_nm=./nm$host_exeext
1757 rm -f nm$host_exeext
1758 $symbolic_link ../binutils/nm-new$host_exeext nm$host_exeext 2>/dev/null
1759 elif test "x$program_prefix" != xNONE; then
1760 gcc_cv_nm=${program_prefix}nm$host_exeext
1762 gcc_cv_nm=`echo nm | sed ${program_transform_name}`$host_exeext
1765 yes) AC_MSG_RESULT("newly built nm") ;;
1766 no) AC_MSG_RESULT($gcc_cv_nm) ;;
1769 # Figure out what objdump we will be using.
1770 AC_MSG_CHECKING(what objdump to use)
1772 if test -x objdump$host_exeext; then
1773 gcc_cv_objdump=./objdump$host_exeext
1774 elif test -f $gcc_cv_binutils_srcdir/configure.in \
1775 && test -f ../binutils/Makefile; then
1776 # Single tree build which includes binutils.
1778 gcc_cv_objdump=./objdump$host_exeext
1779 rm -f objdump$host_exeext
1780 $symbolic_link ../binutils/objdump$host_exeext \
1781 objdump$host_exeext 2>/dev/null
1782 elif test "x$program_prefix" != xNONE; then
1783 gcc_cv_objdump=${program_prefix}objdump$host_exeext
1785 gcc_cv_objdump=`echo objdump | \
1786 sed ${program_transform_name}`$host_exeext
1788 case $in_tree_objdump in
1789 yes) AC_MSG_RESULT("newly built objdump") ;;
1790 no) AC_MSG_RESULT($gcc_cv_objdump) ;;
1793 # Figure out what assembler alignment features are present.
1794 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1798 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
1799 [Define if your assembler supports .balign and .p2align.])])
1801 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
1804 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
1805 [Define if your assembler supports specifying the maximum number
1806 of bytes to skip when using the GAS .p2align command.])])
1808 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
1810 [conftest_label1: .word 0
1812 conftest_label2: .word 0
1814 [if test x$gcc_cv_nm != x; then
1815 $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
1816 $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
1817 if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
1819 else gcc_cv_as_subsection_m1=yes
1821 rm -f conftest.nm1 conftest.nm2
1823 [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
1824 [Define if your assembler supports .subsection and .subsection -1 starts
1825 emitting at the beginning of your section.])])
1827 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
1830 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
1832 # .hidden needs to be supported in both the assembler and the linker,
1833 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
1834 # This is irritatingly difficult to feature test for; we have to check the
1835 # date string after the version number. If we've got an in-tree
1836 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
1838 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
1839 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
1844 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
1845 [if test $in_tree_ld = yes ; then
1847 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 \
1848 && test $in_tree_ld_is_elf = yes; then
1849 gcc_cv_ld_hidden=yes
1852 gcc_cv_ld_hidden=yes
1853 ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
1854 if echo "$ld_ver" | grep GNU > /dev/null; then
1856 ld_vers=`echo $ld_ver | sed -n \
1857 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1858 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1859 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)$,\1,p' \
1860 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
1861 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p' \
1862 -e 's,^.*[ ]\([0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*\)[ ].*$,\1,p'`
1863 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'`
1864 if test 0"$ld_date" -lt 20020404; then
1865 if test -n "$ld_date"; then
1866 # If there was date string, but was earlier than 2002-04-04, fail
1868 elif test -z "$ld_vers"; then
1869 # If there was no date string nor ld version number, something is wrong
1872 ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
1873 ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
1874 ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
1875 test -z "$ld_vers_patch" && ld_vers_patch=0
1876 if test "$ld_vers_major" -lt 2; then
1878 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
1879 gcc_cv_ld_hidden="no"
1880 elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
1889 gcc_cv_ld_hidden=yes
1897 libgcc_visibility=no
1898 AC_SUBST(libgcc_visibility)
1899 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
1900 libgcc_visibility=yes
1901 AC_DEFINE(HAVE_GAS_HIDDEN, 1,
1902 [Define if your assembler and linker support .hidden.])
1905 # Check if we have .[us]leb128, and support symbol arithmetic with it.
1906 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
1914 [# GAS versions before 2.11 do not support uleb128,
1915 # despite appearing to.
1916 # ??? There exists an elf-specific test that will crash
1917 # the assembler. Perhaps it's better to figure out whether
1918 # arbitrary sections are supported and try the test.
1919 as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
1920 if echo "$as_ver" | grep GNU > /dev/null; then
1922 as_ver=`echo $as_ver | sed -e 's/GNU assembler \([0-9.][0-9.]*\).*/\1/'`
1923 as_major=`echo $as_ver | sed 's/\..*//'`
1924 as_minor=`echo $as_ver | sed 's/[^.]*\.\([0-9]*\).*/\1/'`
1926 if test $as_major -eq 2 && test $as_minor -lt 11
1928 else gcc_cv_as_leb128=yes
1931 [AC_DEFINE(HAVE_AS_LEB128, 1,
1932 [Define if your assembler supports .sleb128 and .uleb128.])])
1934 # GAS versions up to and including 2.11.0 may mis-optimize
1936 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
1944 .section .eh_frame,"aw",@progbits
1946 .4byte .LECIE1-.LSCIE1
1960 .4byte .LEFDE1-.LASFDE1
1962 .4byte .LASFDE1-__FRAME_BEGIN__
1970 [ cat > conftest.lit <<EOF
1971 0000 10000000 00000000 017a0001 781a0004 .........z..x...
1972 0010 01000000 12000000 18000000 00000000 ................
1973 0020 08000000 04080000 0044 .........D
1975 cat > conftest.big <<EOF
1976 0000 00000010 00000000 017a0001 781a0004 .........z..x...
1977 0010 00000001 00000012 00000018 00000000 ................
1978 0020 00000008 04000000 0844 .........D
1980 # If the assembler didn't choke, and we can objdump,
1981 # and we got the correct data, then succeed.
1982 if test x$gcc_cv_objdump != x \
1983 && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
1984 | tail -3 > conftest.got \
1985 && { cmp conftest.lit conftest.got > /dev/null 2>&1 \
1986 || cmp conftest.big conftest.got > /dev/null 2>&1; }
1988 gcc_cv_as_eh_frame=yes
1989 elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
1990 gcc_cv_as_eh_frame=buggy
1992 # Uh oh, what do we do now?
1993 gcc_cv_as_eh_frame=no
1996 if test $gcc_cv_as_eh_frame = buggy; then
1997 AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
1998 [Define if your assembler mis-optimizes .eh_frame data.])
2001 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2002 [elf,2,12,0], [--fatal-warnings],
2003 [.section .rodata.str, "aMS", @progbits, 1])
2004 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2005 [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2006 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2008 # Thread-local storage - the check is heavily parametrized.
2017 .section ".tdata","awT",@progbits
2020 ldq $27,__tls_get_addr($29) !literal!1
2021 lda $16,foo($29) !tlsgd!1
2022 jsr $26,($27),__tls_get_addr !lituse_tlsgd!1
2023 ldq $27,__tls_get_addr($29) !literal!2
2024 lda $16,foo($29) !tlsldm!2
2025 jsr $26,($27),__tls_get_addr !lituse_tlsldm!2
2026 ldq $1,foo($29) !gotdtprel
2027 ldah $2,foo($29) !dtprelhi
2028 lda $3,foo($2) !dtprello
2029 lda $4,foo($29) !dtprel
2030 ldq $1,foo($29) !gottprel
2031 ldah $2,foo($29) !tprelhi
2032 lda $3,foo($2) !tprello
2033 lda $4,foo($29) !tprel'
2039 .section ".tdata","awT",@progbits
2043 leal foo@TLSGD(,%ebx,1), %eax
2044 leal foo@TLSLDM(%ebx), %eax
2045 leal foo@DTPOFF(%eax), %edx
2046 movl foo@GOTTPOFF(%ebx), %eax
2047 subl foo@GOTTPOFF(%ebx), %eax
2048 addl foo@GOTNTPOFF(%ebx), %eax
2049 movl foo@INDNTPOFF, %eax
2050 movl $foo@TPOFF, %eax
2051 subl $foo@TPOFF, %eax
2052 leal foo@NTPOFF(%ecx), %eax'
2058 .section ".tdata","awT",@progbits
2062 leaq foo@TLSGD(%rip), %rdi
2063 leaq foo@TLSLD(%rip), %rdi
2064 leaq foo@DTPOFF(%rax), %rdx
2065 movq foo@GOTTPOFF(%rip), %rax
2066 movq $foo@TPOFF, %rax'
2072 .section ".tdata","awT",@progbits
2075 addl r16 = @ltoff(@dtpmod(foo#)), gp
2076 addl r17 = @ltoff(@dtprel(foo#)), gp
2077 addl r18 = @ltoff(@tprel(foo#)), gp
2078 addl r19 = @dtprel(foo#), gp
2079 adds r21 = @dtprel(foo#), r13
2080 movl r23 = @dtprel(foo#)
2081 addl r20 = @tprel(foo#), gp
2082 adds r22 = @tprel(foo#), r13
2083 movl r24 = @tprel(foo#)'
2089 .section ".tdata","awT",@progbits
2097 addi 3,31,ld0@got@tlsgd
2099 addi 3,31,x1@got@tlsld
2102 addis 9,3,x2@dtprel@ha
2103 addi 9,9,x2@dtprel@l
2104 lwz 9,x3@got@tprel(31)
2107 addis 9,2,x2@tprel@ha
2108 addi 9,9,x2@tprel@l'
2115 .section ".tdata","awT",@progbits
2123 addi 3,2,ld0@got@tlsgd
2129 addi 3,2,x1@got@tlsld
2135 addis 9,3,x2@dtprel@ha
2136 addi 9,9,x2@dtprel@l
2139 ld 9,x3@got@dtprel(2)
2149 .section ".tdata","awT",@progbits
2158 l %r1,foo@GOTNTPOFF(%r12)
2159 l %r1,0(%r1):tls_load:foo
2160 bas %r14,0(%r1,%r13):tls_gdcall:foo
2161 bas %r14,0(%r1,%r13):tls_ldcall:foo'
2168 .section ".tdata","awT",@progbits
2176 lg %r1,foo@GOTNTPOFF(%r12)
2177 larl %r1,foo@INDNTPOFF
2178 brasl %r14,__tls_get_offset@PLT:tls_gdcall:foo
2179 brasl %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2182 tls_as_opt="-m64 -Aesame"
2184 sh-*-* | sh[34]-*-*)
2186 .section ".tdata","awT",@progbits
2199 .section ".tdata","awT",@progbits
2202 sethi %tgd_hi22(foo), %o0
2203 add %o0, %tgd_lo10(foo), %o1
2204 add %l7, %o1, %o0, %tgd_add(foo)
2205 call __tls_get_addr, %tgd_call(foo)
2206 sethi %tldm_hi22(foo), %l1
2207 add %l1, %tldm_lo10(foo), %l2
2208 add %l7, %l2, %o0, %tldm_add(foo)
2209 call __tls_get_addr, %tldm_call(foo)
2210 sethi %tldo_hix22(foo), %l3
2211 xor %l3, %tldo_lox10(foo), %l4
2212 add %o0, %l4, %l5, %tldo_add(foo)
2213 sethi %tie_hi22(foo), %o3
2214 add %o3, %tie_lo10(foo), %o3
2215 ld [%l7 + %o3], %o2, %tie_ld(foo)
2216 add %g7, %o2, %o4, %tie_add(foo)
2217 sethi %tle_hix22(foo), %l1
2218 xor %l1, %tle_lox10(foo), %o5
2219 ld [%g7 + %o5], %o1'
2226 if test -z "$tls_first_major"; then
2227 : # If we don't have a check, assume no support.
2229 gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2230 [$tls_first_major,$tls_first_minor,0], [$tls_as_opt --fatal-warnings],
2232 [AC_DEFINE(HAVE_AS_TLS, 1,
2233 [Define if your assembler supports thread-local storage.])])
2236 # Target-specific assembler checks.
2239 # All TARGET_ABI_OSF targets.
2240 alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2241 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2242 gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2245 extbl $3, $2, $3 !lituse_bytoff!1
2246 ldq $2, a($29) !literal!1
2247 ldq $4, b($29) !literal!2
2248 ldq_u $3, 0($2) !lituse_base!1
2249 ldq $27, f($29) !literal!5
2250 jsr $26, ($27), f !lituse_jsr!5
2251 ldah $29, 0($26) !gpdisp!3
2252 lda $0, c($29) !gprel
2253 ldah $1, d($29) !gprelhigh
2254 lda $1, d($1) !gprellow
2255 lda $29, 0($29) !gpdisp!3],,
2256 [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2257 [Define if your assembler supports explicit relocations.])])
2261 gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2262 [.register %g2, #scratch],,
2263 [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2264 [Define if your assembler supports .register.])])
2266 gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2268 [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2269 [Define if your assembler supports -relax option.])])
2271 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2272 gcc_cv_as_sparc_ua_pcrel,,
2280 .uaword %r_disp32(foo)],
2281 [if test x$gcc_cv_ld != x \
2282 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2283 gcc_cv_as_sparc_ua_pcrel=yes
2286 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2287 [Define if your assembler and linker support unaligned PC relative relocs.])
2289 gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2290 gcc_cv_as_sparc_ua_pcrel_hidden,,
2295 .uaword %r_disp32(foo)
2296 .byte 0x32, 0x33, 0x34
2301 [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2302 && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2303 && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2304 | grep ' 31000000 07323334' > /dev/null 2>&1; then
2305 if $gcc_cv_objdump -R conftest 2> /dev/null \
2306 | grep 'DISP32' > /dev/null 2>&1; then
2309 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2313 [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2314 [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2315 ]) # unaligned pcrel relocs
2317 gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2318 gcc_cv_as_sparc_offsetable_lo10,,
2321 or %g1, %lo(ab) + 12, %g1
2322 or %g1, %lo(ab + 12), %g1],
2323 [if test x$gcc_cv_objdump != x \
2324 && %gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2325 | grep ' 82106000 82106000' > /dev/null 2>&1; then
2326 gcc_cv_as_offsetable_lo10=yes
2328 [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2329 [Define if your assembler supports offsetable %lo().])])
2333 i[34567]86-*-* | x86_64-*-*)
2335 gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2336 gcc_cv_as_ix86_filds_fists,
2337 [2,9,0],, [filds mem; fists mem],,
2338 [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2339 [Define if your assembler uses the new HImode fild and fist notation.])])
2341 gcc_GAS_CHECK_FEATURE([cmov syntax],
2342 gcc_cv_as_ix86_cmov_sun_syntax,,,
2343 [cmovl.l %edx, %eax],,
2344 [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2345 [Define if your assembler supports the Sun syntax for cmov.])])
2347 # This one is used unconditionally by i386.[ch]; it is to be defined
2348 # to 1 if the feature is present, 0 otherwise.
2349 gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2350 gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2356 AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2357 [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2358 [Define true if the assembler supports '.long foo@GOTOFF'.])
2362 gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2363 gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2365 addl r15 = @ltoffx(x#), gp
2367 ld8.mov r16 = [[r15]], x#],,
2368 [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2369 [Define if your assembler supports ltoffx and ldxmov relocations.])])
2375 *-*-aix) conftest_s=' .csect .text[PR]';;
2376 *) conftest_s=' .text';;
2378 conftest_s="$conftest_s
2381 gcc_GAS_CHECK_FEATURE([mfcr field support],
2382 gcc_cv_as_powerpc_mfcrf, [2,14,0],,
2384 [AC_DEFINE(HAVE_AS_MFCRF, 1,
2385 [Define if your assembler supports mfcr field.])])
2389 gcc_GAS_CHECK_FEATURE([explicit relocation support],
2390 gcc_cv_as_mips_explicit_relocs, [2,14,0],,
2391 [ lw $4,%gp_rel(foo)($4)],,
2392 [if test x$target_cpu_default = x
2393 then target_cpu_default=MASK_EXPLICIT_RELOCS
2394 else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
2399 # ??? Not all targets support dwarf2 debug_line, even within a version
2400 # of gas. Moreover, we need to emit a valid instruction to trigger any
2401 # info to the output file. So, as supported targets are added to gas 2.11,
2402 # add some instruction here to (also) show we expect this might work.
2403 # ??? Once 2.11 is released, probably need to add first known working
2404 # version to the per-target configury.
2406 i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
2407 | x86_64*-*-* | hppa*-*-* | arm*-*-* | strongarm*-*-* | xscale*-*-* \
2408 | xstormy16*-*-* | cris-*-* | xtensa-*-*)
2418 if test x"$insn" != x; then
2420 .file 1 \"conftest.s\"
2423 gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
2424 gcc_cv_as_dwarf2_debug_line,
2425 [elf,2,11,0],, [$conftest_s],
2426 [# ??? This fails with non-gnu grep. Maybe use objdump?
2427 if grep debug_line conftest.o > /dev/null 2>&1; then
2428 gcc_cv_as_dwarf2_debug_line=yes
2431 # The .debug_line file table must be in the exact order that
2432 # we specified the files, since these indices are also used
2433 # by DW_AT_decl_file. Approximate this test by testing if
2434 # the assembler bitches if the same index is assigned twice.
2435 gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
2436 gcc_cv_as_dwarf2_file_buggy,,,
2440 if test $gcc_cv_as_dwarf2_debug_line = yes \
2441 && test $gcc_cv_as_dwarf2_file_buggy = no; then
2442 AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
2443 [Define if your assembler supports dwarf2 .file/.loc directives,
2444 and preserves file table indices exactly as given.])
2447 gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
2448 gcc_cv_as_gdwarf2_flag,
2449 [elf,2,11,0], [--gdwarf2], [$insn],,
2450 [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
2451 [Define if your assembler supports the --gdwarf2 option.])])
2453 gcc_GAS_CHECK_FEATURE([--gstabs option],
2454 gcc_cv_as_gstabs_flag,
2455 [elf,2,11,0], [--gstabs], [$insn],
2456 [# The native Solaris 9/Intel assembler doesn't understand --gstabs
2457 # and warns about it, but still exits successfully. So check for
2459 if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
2461 else gcc_cv_as_gstabs_flag=yes
2463 [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
2464 [Define if your assembler supports the --gstabs option.])])
2467 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2468 gcc_cv_ld_ro_rw_mix=unknown
2469 if test $in_tree_ld = yes ; then
2470 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 \
2471 && test $in_tree_ld_is_elf = yes; then
2472 gcc_cv_ld_ro_rw_mix=read-write
2474 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2475 echo '.section myfoosect, "a"' > conftest1.s
2476 echo '.section myfoosect, "aw"' > conftest2.s
2477 echo '.byte 1' >> conftest2.s
2478 echo '.section myfoosect, "a"' > conftest3.s
2479 echo '.byte 0' >> conftest3.s
2480 if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2481 && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2482 && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2483 && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2484 conftest2.o conftest3.o > /dev/null 2>&1; then
2485 gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2486 | sed -e '/myfoosect/!d' -e N`
2487 if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2488 if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2489 gcc_cv_ld_ro_rw_mix=read-only
2491 gcc_cv_ld_ro_rw_mix=read-write
2496 rm -f conftest.* conftest[123].*
2499 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2500 AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2501 [Define if your linker links a mix of read-only
2502 and read-write sections into a read-write section.])
2504 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2506 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
2507 gcc_cv_ld_eh_frame_hdr=no
2508 if test $in_tree_ld = yes ; then
2509 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 \
2510 && test $in_tree_ld_is_elf = yes; then
2511 gcc_cv_ld_eh_frame_hdr=yes
2513 elif test x$gcc_cv_ld != x; then
2514 # Check if linker supports --eh-frame-hdr option
2515 if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
2516 gcc_cv_ld_eh_frame_hdr=yes
2519 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
2520 AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
2521 [Define if your linker supports --eh-frame-hdr option.])
2523 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
2525 AC_MSG_CHECKING(linker position independent executable support)
2527 if test $in_tree_ld = yes ; then
2528 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 \
2529 && test $in_tree_ld_is_elf = yes; then
2532 elif test x$gcc_cv_ld != x; then
2533 # Check if linker supports -pie option
2534 if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
2538 if test x"$gcc_cv_ld_pie" = xyes; then
2539 AC_DEFINE(HAVE_LD_PIE, 1,
2540 [Define if your linker supports -pie option.])
2542 AC_MSG_RESULT($gcc_cv_ld_pie)
2544 if test x$with_sysroot = x && test x$host = x$target \
2545 && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" ; then
2546 AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
2547 [Define to PREFIX/include if cpp should also search that directory.])
2550 # Figure out what language subdirectories are present.
2551 # Look if the user specified --enable-languages="..."; if not, use
2552 # the environment variable $LANGUAGES if defined. $LANGUAGES might
2554 # NB: embedded tabs in this IF block -- do not untabify
2555 if test x"${enable_languages+set}" != xset; then
2556 if test x"${LANGUAGES+set}" = xset; then
2557 enable_languages="${LANGUAGES}"
2558 AC_MSG_WARN([setting LANGUAGES is deprecated, use --enable-languages instead])
2561 enable_languages=all
2564 if test x"${enable_languages}" = x \
2565 || test x"${enable_languages}" = xyes;
2567 AC_MSG_ERROR([--enable-languages needs at least one language argument])
2570 enable_languages=`echo "${enable_languages}" | sed -e 's/[[ ,]][[ ,]]*/,/g' -e 's/,$//'`
2572 # First scan to see if an enabled language requires some other language.
2573 # We assume that a given config-lang.in will list all the language
2574 # front ends it requires, even if some are required indirectly.
2575 for lang in ${srcdir}/*/config-lang.in
2578 # The odd quoting in the next line works around
2579 # an apparent bug in bash 1.12 on linux.
2581 ${srcdir}/[*]/config-lang.in)
2584 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
2585 this_lang_requires=`sed -n -e 's,^lang_requires=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^lang_requires=\([^ ]*\).*$,\1,p' $lang`
2586 for other in $this_lang_requires
2588 case ,${enable_languages}, in
2594 enable_languages="$enable_languages,$other"
2603 expected_languages=`echo ,${enable_languages}, | sed -e 's:,: :g' -e 's: *: :g' -e 's: *: :g' -e 's:^ ::' -e 's: $::'`
2606 for lang in ${srcdir}/*/config-lang.in
2609 # The odd quoting in the next line works around
2610 # an apparent bug in bash 1.12 on linux.
2612 ${srcdir}/[*]/config-lang.in) ;;
2614 lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^ ]*\).*$,\1,p' $lang`
2615 this_lang_libs=`sed -n -e 's,^target_libs=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^target_libs=\([^ ]*\).*$,\1,p' $lang`
2616 build_by_default=`sed -n -e 's,^build_by_default=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^build_by_default=\([^ ]*\).*$,\1,p' $lang`
2617 if test "x$lang_alias" = x
2619 echo "$lang doesn't set \$language." 1>&2
2622 case ${build_by_default},${enable_languages}, in
2623 *,$lang_alias,*) add_this_lang=yes ;;
2624 no,*) add_this_lang=no ;;
2625 *,all,*) add_this_lang=yes ;;
2626 *) add_this_lang=no ;;
2628 found_languages="${found_languages} ${lang_alias}"
2629 if test x"${add_this_lang}" = xyes; then
2631 ${srcdir}/ada/config-lang.in)
2632 if test x$have_gnat = xyes ; then
2633 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2637 subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
2647 for expected_language in ${expected_languages} ..
2649 if test "${expected_language}" != ..; then
2650 missing_language="${expected_language}"
2651 if test "${expected_language}" = "c" \
2652 || test "${expected_language}" = "all"; then
2655 for found_language in ${found_languages} ..
2657 if test "${found_language}" != ..; then
2658 if test "${expected_language}" = "${found_language}"; then
2663 if test "x${missing_language}" != x; then
2664 missing_languages="${missing_languages} ${missing_language}"
2669 if test "x$missing_languages" != x; then
2671 The following requested languages were not found:${missing_languages}
2672 The following languages were available: c${found_languages}])
2675 # Make gthr-default.h if we have a thread file.
2677 if test $thread_file != single; then
2678 rm -f gthr-default.h
2679 echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h
2680 gthread_flags=-DHAVE_GTHR_DEFAULT
2682 AC_SUBST(gthread_flags)
2684 # Find out what GC implementation we want, or may, use.
2686 [ --with-gc={simple,page,zone} choose the garbage collection mechanism to use
2689 simple | page | zone)
2693 AC_MSG_ERROR([$withval is an invalid option to --with-gc])
2698 echo "Using $GGC for garbage collection."
2700 # Use the system's zlib library.
2702 zlibinc="-I\$(srcdir)/../zlib"
2703 AC_ARG_WITH(system-zlib,
2704 [ --with-system-zlib use installed libz],
2711 dnl Very limited version of automake's enable-maintainer-mode
2713 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
2714 dnl maintainer-mode is disabled by default
2715 AC_ARG_ENABLE(maintainer-mode,
2716 [ --enable-maintainer-mode
2717 enable make rules and dependencies not useful
2718 (and sometimes confusing) to the casual installer],
2719 maintainer_mode=$enableval,
2722 AC_MSG_RESULT($maintainer_mode)
2724 if test "$maintainer_mode" = "yes"; then
2731 # Make empty files to contain the specs and options for each language.
2732 # Then add #include lines to for a compiler that has specs and/or options.
2737 for subdir in . $subdirs
2739 if test -f $srcdir/$subdir/lang.opt; then
2740 lang_opt_files="$lang_opt_files $srcdir/$subdir/lang.opt"
2742 if test -f $srcdir/$subdir/lang-specs.h; then
2743 lang_specs_files="$lang_specs_files $srcdir/$subdir/lang-specs.h"
2745 if test -f $srcdir/$subdir/$subdir-tree.def; then
2746 lang_tree_files="$lang_tree_files $srcdir/$subdir/$subdir-tree.def"
2750 # These (without "all_") are set in each config-lang.in.
2751 # `language' must be a single word so is spelled singularly.
2756 all_outputs='Makefile fixinc/Makefile gccbug mklibgcc mkheaders'
2757 # List of language makefile fragments.
2759 # List of language subdirectory makefiles. Deprecated.
2761 # Files for gengtype
2762 all_gtfiles="$target_gtfiles"
2763 # Files for gengtype with language
2764 all_gtfiles_files_langs=
2765 all_gtfiles_files_files=
2767 # Add the language fragments.
2768 # Languages are added via two mechanisms. Some information must be
2769 # recorded in makefile variables, these are defined in config-lang.in.
2770 # We accumulate them and plug them into the main Makefile.
2771 # The other mechanism is a set of hooks for each of the main targets
2772 # like `clean', `install', etc.
2774 language_hooks="Make-hooks"
2784 . ${srcdir}/$s/config-lang.in
2785 if test "x$language" = x
2787 echo "${srcdir}/$s/config-lang.in doesn't set \$language." 1>&2
2790 all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$s/Make-lang.in"
2791 if test -f ${srcdir}/$s/Makefile.in
2792 then all_lang_makefiles="$s/Makefile"
2794 all_languages="$all_languages $language"
2795 if test "x$boot_language" = xyes
2797 all_boot_languages="$all_boot_languages $language"
2799 all_compilers="$all_compilers $compilers"
2800 all_stagestuff="$all_stagestuff $stagestuff"
2801 all_outputs="$all_outputs $outputs"
2802 all_gtfiles="$all_gtfiles $gtfiles"
2805 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2806 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2810 # Pick up gtfiles for c
2813 . ${srcdir}/c-config-lang.in
2814 all_gtfiles="$all_gtfiles $gtfiles"
2817 all_gtfiles_files_langs="$all_gtfiles_files_langs ${s} "
2818 all_gtfiles_files_files="$all_gtfiles_files_files ${f} "
2822 for language in $all_languages
2824 check_languages="$check_languages check-$language"
2827 # We link each language in with a set of hooks, reached indirectly via
2832 target_list="all.build all.cross start.encap rest.encap tags \
2833 install-normal install-common install-man \
2835 mostlyclean clean distclean maintainer-clean \
2836 stage1 stage2 stage3 stage4 stageprofile stagefeedback"
2837 for t in $target_list
2840 for lang in $all_languages
2844 echo "lang.$t: $x" >> Make-hooks
2849 echo "dir ." > .gdbinit
2850 echo "dir ${srcdir}" >> .gdbinit
2851 if test x$gdb_needs_out_file_path = xyes
2853 echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
2855 if test "x$subdirs" != x; then
2858 echo "dir ${srcdir}/$s" >> .gdbinit
2861 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
2863 # If $(exec_prefix) exists and is not the same as $(prefix), then compute an
2864 # absolute path for gcc_tooldir based on inserting the number of up-directory
2865 # movements required to get from $(exec_prefix) to $(prefix) into the basic
2866 # $(libsubdir)/@(unlibsubdir) based path.
2867 # Don't set gcc_tooldir to tooldir since that's only passed in by the toplevel
2868 # make and thus we'd get different behavior depending on where we built the
2870 if test x$exec_prefix = xNONE -o x$exec_prefix = x$prefix; then
2871 gcc_tooldir='$(libsubdir)/$(unlibsubdir)/../$(target_noncanonical)'
2873 changequote(<<, >>)dnl
2874 # An explanation of the sed strings:
2875 # -e 's|^\$(prefix)||' matches and eliminates 'prefix' from 'exec_prefix'
2876 # -e 's|/$||' match a trailing forward slash and eliminates it
2877 # -e 's|^[^/]|/|' forces the string to start with a forward slash (*)
2878 # -e 's|/[^/]*|../|g' replaces each occurrence of /<directory> with ../
2880 # (*) Note this pattern overwrites the first character of the string
2881 # with a forward slash if one is not already present. This is not a
2882 # problem because the exact names of the sub-directories concerned is
2883 # unimportant, just the number of them matters.
2885 # The practical upshot of these patterns is like this:
2887 # prefix exec_prefix result
2888 # ------ ----------- ------
2890 # /foo/ /foo/bar ../
2891 # /foo /foo/bar/ ../
2892 # /foo/ /foo/bar/ ../
2893 # /foo /foo/bar/ugg ../../
2896 gcc_tooldir="\$(libsubdir)/\$(unlibsubdir)/\`echo \$(exec_prefix) | sed -e 's|^\$(prefix)||' -e 's|/\$(dollar)||' -e 's|^[^/]|/|' -e 's|/[^/]*|../|g'\`\$(target_noncanonical)"
2897 changequote([, ])dnl
2899 AC_SUBST(gcc_tooldir)
2902 # Find a directory in which to install a shared libgcc.
2904 AC_ARG_ENABLE(version-specific-runtime-libs,
2905 [ --enable-version-specific-runtime-libs
2906 specify that runtime libraries should be
2907 installed in a compiler-specific directory])
2909 AC_ARG_WITH(slibdir,
2910 [ --with-slibdir=DIR shared libraries in DIR [LIBDIR]],
2911 slibdir="$with_slibdir",
2912 if test "${enable_version_specific_runtime_libs+set}" = set; then
2913 slibdir='$(libsubdir)'
2914 elif test "$host" != "$target"; then
2915 slibdir='$(build_tooldir)/lib'
2921 objdir=`${PWDCMD-pwd}`
2924 # Substitute configuration variables
2929 AC_SUBST(all_boot_languages)
2930 AC_SUBST(all_compilers)
2931 AC_SUBST(all_gtfiles)
2932 AC_SUBST(all_gtfiles_files_langs)
2933 AC_SUBST(all_gtfiles_files_files)
2934 AC_SUBST(all_lang_makefrags)
2935 AC_SUBST(all_lang_makefiles)
2936 AC_SUBST(all_languages)
2937 AC_SUBST(all_stagestuff)
2938 AC_SUBST(build_exeext)
2939 AC_SUBST(build_install_headers_dir)
2940 AC_SUBST(build_xm_file_list)
2941 AC_SUBST(build_xm_include_list)
2942 AC_SUBST(build_xm_defines)
2943 AC_SUBST(check_languages)
2944 AC_SUBST(cc_set_by_configure)
2945 AC_SUBST(quoted_cc_set_by_configure)
2946 AC_SUBST(cpp_install_dir)
2947 AC_SUBST(xmake_file)
2948 AC_SUBST(tmake_file)
2949 AC_SUBST(extra_headers_list)
2950 AC_SUBST(extra_objs)
2951 AC_SUBST(extra_parts)
2952 AC_SUBST(extra_passes)
2953 AC_SUBST(extra_programs)
2954 AC_SUBST(float_h_file)
2955 AC_SUBST(gcc_config_arguments)
2956 AC_SUBST(gcc_gxx_include_dir)
2957 AC_SUBST(libstdcxx_incdir)
2958 AC_SUBST(gcc_version)
2959 AC_SUBST(gcc_version_full)
2960 AC_SUBST(gcc_version_trigger)
2961 AC_SUBST(host_exeext)
2962 AC_SUBST(host_extra_gcc_objs)
2963 AC_SUBST(host_xm_file_list)
2964 AC_SUBST(host_xm_include_list)
2965 AC_SUBST(host_xm_defines)
2966 AC_SUBST(out_host_hook_obj)
2968 AC_SUBST(lang_opt_files)
2969 AC_SUBST(lang_specs_files)
2970 AC_SUBST(lang_tree_files)
2971 AC_SUBST(local_prefix)
2973 AC_SUBST(objc_boehm_gc)
2975 AC_SUBST(out_object_file)
2976 AC_SUBST(stage_prefix_set_by_configure)
2977 AC_SUBST(quoted_stage_prefix_set_by_configure)
2978 AC_SUBST(symbolic_link)
2979 AC_SUBST(thread_file)
2980 AC_SUBST(tm_file_list)
2981 AC_SUBST(tm_include_list)
2982 AC_SUBST(tm_defines)
2983 AC_SUBST(tm_p_file_list)
2984 AC_SUBST(tm_p_include_list)
2985 AC_SUBST(xm_file_list)
2986 AC_SUBST(xm_include_list)
2987 AC_SUBST(xm_defines)
2988 AC_SUBST(target_noncanonical)
2989 AC_SUBST(c_target_objs)
2990 AC_SUBST(cxx_target_objs)
2991 AC_SUBST(target_cpu_default)
2993 AC_SUBST_FILE(language_hooks)
2996 if test x${build} = x${host} ; then
2997 if test x${host} = x${target} ; then
2998 echo "Links are now set up to build a native compiler for ${target}." 1>&2
3000 echo "Links are now set up to build a cross-compiler" 1>&2
3001 echo " from ${host} to ${target}." 1>&2
3004 if test x${host} = x${target} ; then
3005 echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3006 echo " for ${target}." 1>&2
3008 echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3009 echo " from ${host} to ${target}." 1>&2
3013 # Configure the subdirectories
3014 # AC_CONFIG_SUBDIRS($subdirs)
3016 # Create the Makefile
3017 # and configure language subdirectories
3018 AC_OUTPUT($all_outputs,
3020 case ${CONFIG_HEADERS} in
3021 *auto-host.h:config.in*)
3024 # Make sure all the subdirs exist.
3027 test -d $d || mkdir $d
3029 # If the host supports symlinks, point stage[1234] at ../stage[1234] so
3030 # bootstrapping and the installation procedure can still use
3031 # CC="stage1/xgcc -Bstage1/". If the host doesn't support symlinks,
3032 # FLAGS_TO_PASS has been modified to solve the problem there.
3033 # This is virtually a duplicate of what happens in configure.lang; we do
3034 # an extra check to make sure this only happens if ln -s can be used.
3035 if test "$symbolic_link" = "ln -s"; then
3036 for d in ${subdirs} fixinc ; do
3037 STARTDIR=`${PWDCMD-pwd}`
3039 for t in stage1 stage2 stage3 stage4 stageprofile stagefeedback include
3042 $symbolic_link ../$t $t 2>/dev/null
3049 symbolic_link='$symbolic_link'