OSDN Git Service

2009-04-14 Diego Novillo <dnovillo@google.com>
[pf3gnuchains/gcc-fork.git] / gcc / configure.ac
1 # configure.ac for GCC
2 # Process this file with autoconf to generate a configuration script.
3
4 # Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
5 # 2007, 2008, 2009 Free Software Foundation, Inc.
6
7 #This file is part of GCC.
8
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 3, or (at your option) any later
12 #version.
13
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
17 #for more details.
18
19 #You should have received a copy of the GNU General Public License
20 #along with GCC; see the file COPYING3.  If not see
21 #<http://www.gnu.org/licenses/>.
22
23 # --------------------------------
24 # Initialization and sanity checks
25 # --------------------------------
26
27 AC_PREREQ(2.59)
28 AC_INIT
29 AC_CONFIG_SRCDIR(tree.c)
30 AC_CONFIG_HEADER(auto-host.h:config.in)
31
32 gcc_version=`cat $srcdir/BASE-VER`
33
34 # Determine the host, build, and target systems
35 AC_CANONICAL_BUILD
36 AC_CANONICAL_HOST
37 AC_CANONICAL_TARGET
38
39 # Determine the noncanonical target name, for directory use.
40 ACX_NONCANONICAL_TARGET
41
42 # Determine the target- and build-specific subdirectories
43 GCC_TOPLEV_SUBDIRS
44
45 # Set program_transform_name
46 AC_ARG_PROGRAM
47
48 # Check for bogus environment variables.
49 # Test if LIBRARY_PATH contains the notation for the current directory
50 # since this would lead to problems installing/building glibc.
51 # LIBRARY_PATH contains the current directory if one of the following
52 # is true:
53 # - one of the terminals (":" and ";") is the first or last sign
54 # - two terminals occur directly after each other
55 # - the path contains an element with a dot in it
56 AC_MSG_CHECKING(LIBRARY_PATH variable)
57 changequote(,)dnl
58 case ${LIBRARY_PATH} in
59   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
60     library_path_setting="contains current directory"
61     ;;
62   *)
63     library_path_setting="ok"
64     ;;
65 esac
66 changequote([,])dnl
67 AC_MSG_RESULT($library_path_setting)
68 if test "$library_path_setting" != "ok"; then
69 AC_MSG_ERROR([
70 *** LIBRARY_PATH shouldn't contain the current directory when
71 *** building gcc. Please change the environment variable
72 *** and run configure again.])
73 fi
74
75 # Test if GCC_EXEC_PREFIX contains the notation for the current directory
76 # since this would lead to problems installing/building glibc.
77 # GCC_EXEC_PREFIX contains the current directory if one of the following
78 # is true:
79 # - one of the terminals (":" and ";") is the first or last sign
80 # - two terminals occur directly after each other
81 # - the path contains an element with a dot in it
82 AC_MSG_CHECKING(GCC_EXEC_PREFIX variable)
83 changequote(,)dnl
84 case ${GCC_EXEC_PREFIX} in
85   [:\;]* | *[:\;] | *[:\;][:\;]* |  *[:\;]. | .[:\;]*| . | *[:\;].[:\;]* )
86     gcc_exec_prefix_setting="contains current directory"
87     ;;
88   *)
89     gcc_exec_prefix_setting="ok"
90     ;;
91 esac
92 changequote([,])dnl
93 AC_MSG_RESULT($gcc_exec_prefix_setting)
94 if test "$gcc_exec_prefix_setting" != "ok"; then
95 AC_MSG_ERROR([
96 *** GCC_EXEC_PREFIX shouldn't contain the current directory when
97 *** building gcc. Please change the environment variable
98 *** and run configure again.])
99 fi
100
101 # -----------
102 # Directories
103 # -----------
104
105 # Specify the local prefix
106 local_prefix=
107 AC_ARG_WITH(local-prefix,
108 [  --with-local-prefix=DIR specifies directory to put local include],
109 [case "${withval}" in
110 yes)    AC_MSG_ERROR(bad value ${withval} given for local include directory prefix) ;;
111 no)     ;;
112 *)      local_prefix=$with_local_prefix ;;
113 esac])
114
115 # Default local prefix if it is empty
116 if test x$local_prefix = x; then
117         local_prefix=/usr/local
118 fi
119
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.
123 gcc_gxx_include_dir=
124 # Specify the g++ header file directory
125 AC_ARG_WITH(gxx-include-dir,
126 [  --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) ;;
130 no)     ;;
131 *)      gcc_gxx_include_dir=$with_gxx_include_dir ;;
132 esac])
133
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++'
138   else
139     libstdcxx_incdir='include/c++/$(version)'
140     if test x$host != x$target; then
141        libstdcxx_incdir="$target_alias/$libstdcxx_incdir"
142     fi
143     gcc_gxx_include_dir="\$(libsubdir)/\$(libsubdir_to_prefix)$libstdcxx_incdir"
144   fi
145 fi
146
147 AC_ARG_WITH(cpp_install_dir,
148 [  --with-cpp-install-dir=DIR
149                           install the user visible C preprocessor in DIR
150                           (relative to PREFIX) as well as PREFIX/bin],
151 [if test x$withval = xyes; then
152   AC_MSG_ERROR([option --with-cpp-install-dir requires an argument])
153 elif test x$withval != xno; then
154   cpp_install_dir=$withval
155 fi])
156
157 # We would like to our source tree to be readonly.  However when releases or
158 # pre-releases are generated, the flex/bison generated files as well as the 
159 # various formats of manuals need to be included along with the rest of the
160 # sources.  Therefore we have --enable-generated-files-in-srcdir to do 
161 # just that.
162
163 AC_MSG_CHECKING([whether to place generated files in the source directory])
164   dnl generated-files-in-srcdir is disabled by default
165   AC_ARG_ENABLE(generated-files-in-srcdir, 
166 [  --enable-generated-files-in-srcdir
167                           put copies of generated files in source dir
168                           intended for creating source tarballs for users
169                           without texinfo bison or flex.],
170       generated_files_in_srcdir=$enableval,
171       generated_files_in_srcdir=no)
172
173 AC_MSG_RESULT($generated_files_in_srcdir)
174
175 if test "$generated_files_in_srcdir" = "yes"; then
176   GENINSRC=''
177 else
178   GENINSRC='#'
179 fi
180 AC_SUBST(GENINSRC)
181
182 # -------------------
183 # Find default linker
184 # -------------------
185
186 # With GNU ld
187 AC_ARG_WITH(gnu-ld,
188 [  --with-gnu-ld           arrange to work with GNU ld.],
189 gnu_ld_flag="$with_gnu_ld",
190 gnu_ld_flag=no)
191
192 # With pre-defined ld
193 AC_ARG_WITH(ld,
194 [  --with-ld               arrange to use the specified ld (full pathname)],
195 DEFAULT_LINKER="$with_ld")
196 if test x"${DEFAULT_LINKER+set}" = x"set"; then
197   if test ! -x "$DEFAULT_LINKER"; then
198     AC_MSG_ERROR([cannot execute: $DEFAULT_LINKER: check --with-ld or env. var. DEFAULT_LINKER])
199   elif $DEFAULT_LINKER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
200     gnu_ld_flag=yes
201   fi
202   AC_DEFINE_UNQUOTED(DEFAULT_LINKER,"$DEFAULT_LINKER",
203         [Define to enable the use of a default linker.])
204 fi
205
206 gnu_ld=`if test x"$gnu_ld_flag" = x"yes"; then echo 1; else echo 0; fi`
207 AC_DEFINE_UNQUOTED(HAVE_GNU_LD, $gnu_ld, [Define if using GNU ld.])
208
209 AC_MSG_CHECKING([whether a default linker was specified])
210 if test x"${DEFAULT_LINKER+set}" = x"set"; then
211   if test x"$gnu_ld_flag" = x"no"; then
212     AC_MSG_RESULT([yes ($DEFAULT_LINKER)])
213   else
214     AC_MSG_RESULT([yes ($DEFAULT_LINKER - GNU ld)])
215   fi
216 else
217   AC_MSG_RESULT(no)
218 fi
219
220 # With demangler in GNU ld
221 AC_ARG_WITH(demangler-in-ld,
222 [  --with-demangler-in-ld  try to use demangler in GNU ld.],
223 demangler_in_ld="$with_demangler_in_ld",
224 demangler_in_ld=no)
225
226 # ----------------------
227 # Find default assembler
228 # ----------------------
229
230 # With GNU as
231 AC_ARG_WITH(gnu-as,
232 [  --with-gnu-as           arrange to work with GNU as],
233 gas_flag="$with_gnu_as",
234 gas_flag=no)
235
236 AC_ARG_WITH(as,
237 [  --with-as               arrange to use the specified as (full pathname)],
238 DEFAULT_ASSEMBLER="$with_as")
239 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
240   if test ! -x "$DEFAULT_ASSEMBLER"; then
241     AC_MSG_ERROR([cannot execute: $DEFAULT_ASSEMBLER: check --with-as or env. var. DEFAULT_ASSEMBLER])
242   elif $DEFAULT_ASSEMBLER -v < /dev/null 2>&1 | grep GNU > /dev/null; then
243     gas_flag=yes
244   fi
245   AC_DEFINE_UNQUOTED(DEFAULT_ASSEMBLER,"$DEFAULT_ASSEMBLER",
246         [Define to enable the use of a default assembler.])
247 fi
248
249 gnu_as=`if test x"$gas_flag" = x"yes"; then echo 1; else echo 0; fi`
250 AC_DEFINE_UNQUOTED(HAVE_GNU_AS, $gnu_as, [Define if using GNU as.])
251
252 AC_MSG_CHECKING([whether a default assembler was specified])
253 if test x"${DEFAULT_ASSEMBLER+set}" = x"set"; then
254   if test x"$gas_flag" = x"no"; then
255     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER)])
256   else
257     AC_MSG_RESULT([yes ($DEFAULT_ASSEMBLER - GNU as)])
258   fi
259 else
260   AC_MSG_RESULT(no)
261 fi
262
263 # ---------------
264 # Find C compiler
265 # ---------------
266
267 # If a non-executable a.out is present (e.g. created by GNU as above even if
268 # invoked with -v only), the IRIX 6 native ld just overwrites the existing
269 # file, even when creating an executable, so an execution test fails.
270 # Remove possible default executable files to avoid this.
271 #
272 # FIXME: This really belongs into AC_PROG_CC and can be removed once
273 # Autoconf includes it.
274 rm -f a.out a.exe b.out
275
276 # Find the native compiler
277 AC_PROG_CC
278 AM_PROG_CC_C_O
279 ACX_PROG_GNAT([-I"$srcdir"/ada])
280
281 # autoconf is lame and doesn't give us any substitution variable for this.
282 if eval "test \"`echo '$ac_cv_prog_cc_'${ac_cc}_c_o`\" = no"; then
283   NO_MINUS_C_MINUS_O=yes
284 else
285   OUTPUT_OPTION='-o $@'
286 fi
287 AC_SUBST(NO_MINUS_C_MINUS_O)
288 AC_SUBST(OUTPUT_OPTION)
289
290 # Remove the -O2: for historical reasons, unless bootstrapping we prefer
291 # optimizations to be activated explicitly by the toplevel.
292 case "$CC" in
293   */prev-gcc/xgcc*) ;;
294   *) CFLAGS=`echo $CFLAGS | sed "s/-O[[s0-9]]* *//" ` ;;
295 esac
296 AC_SUBST(CFLAGS)
297
298 # -------------------------
299 # Check C compiler features
300 # -------------------------
301
302 AC_USE_SYSTEM_EXTENSIONS
303 AC_PROG_CPP
304 AC_C_INLINE
305
306 # sizeof(char) is 1 by definition.
307 AC_CHECK_SIZEOF(void *)
308 AC_CHECK_SIZEOF(short)
309 AC_CHECK_SIZEOF(int)
310 AC_CHECK_SIZEOF(long)
311 AC_CHECK_TYPES([long long], [AC_CHECK_SIZEOF(long long)])
312 AC_CHECK_TYPES([__int64], [AC_CHECK_SIZEOF(__int64)])
313
314 # ---------------------
315 # Warnings and checking
316 # ---------------------
317
318 # Check $CC warning features (if it's GCC).
319 # We want to use -pedantic, but we don't want warnings about
320 # * 'long long'
321 # * variadic macros
322 # * overlong strings
323 # So, we only use -pedantic if we can disable those warnings.
324
325 ACX_PROG_CC_WARNING_OPTS(
326         m4_quote(m4_do([-W -Wall -Wwrite-strings -Wstrict-prototypes ],
327                        [-Wmissing-prototypes -Wcast-qual])), [loose_warn])
328 ACX_PROG_CC_WARNING_OPTS(
329         m4_quote(m4_do([-Wold-style-definition -Wc++-compat ], 
330                        [-Wmissing-format-attribute])), [strict_warn])
331 ACX_PROG_CC_WARNING_ALMOST_PEDANTIC(
332         m4_quote(m4_do([-Wno-long-long -Wno-variadic-macros ], 
333                        [-Wno-overlength-strings])), [strict_warn])
334 ACX_PROG_CC_WARNINGS_ARE_ERRORS([manual], [strict_warn])
335
336 # The above macros do nothing if the compiler is not GCC.  However, the
337 # Makefile has more goo to add other flags, so this variabl is used to
338 # enables warnings only for GCC.
339 warn_cflags=
340 if test "x$GCC" = "xyes"; then
341   warn_cflags='$(GCC_WARN_CFLAGS)'
342 fi
343 AC_SUBST(warn_cflags)
344
345 # Enable expensive internal checks
346 is_release=
347 if test x"`cat $srcdir/DEV-PHASE`" != xexperimental; then
348   is_release=yes
349 fi
350
351 AC_ARG_ENABLE(checking,
352 [  --enable-checking[=LIST]
353                           enable expensive run-time checks.  With LIST,
354                           enable only specific categories of checks.
355                           Categories are: yes,no,all,none,release.
356                           Flags are: assert,df,fold,gc,gcac,gimple,misc,
357                           rtlflag,rtl,runtime,tree,valgrind,types.],
358 [ac_checking_flags="${enableval}"],[
359 # Determine the default checks.
360 if test x$is_release = x ; then
361   ac_checking_flags=yes
362 else
363   ac_checking_flags=release
364 fi])
365 IFS="${IFS=     }"; ac_save_IFS="$IFS"; IFS="$IFS,"
366 for check in release $ac_checking_flags
367 do
368         case $check in
369         # these set all the flags to specific states
370         yes)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking= ;
371                         ac_fold_checking= ; ac_gc_checking=1 ;
372                         ac_gc_always_collect= ; ac_gimple_checking=1 ; ac_rtl_checking= ;
373                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
374                         ac_tree_checking=1 ; ac_valgrind_checking= ;
375                         ac_types_checking=1 ;;
376         no|none)        ac_assert_checking= ; ac_checking= ; ac_df_checking= ;
377                         ac_fold_checking= ; ac_gc_checking= ;
378                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
379                         ac_rtlflag_checking= ; ac_runtime_checking= ;
380                         ac_tree_checking= ; ac_valgrind_checking= ;
381                         ac_types_checking= ;;
382         all)            ac_assert_checking=1 ; ac_checking=1 ; ac_df_checking=1 ;
383                         ac_fold_checking=1 ; ac_gc_checking=1 ;
384                         ac_gc_always_collect=1 ; ac_gimple_checking=1 ; ac_rtl_checking=1 ;
385                         ac_rtlflag_checking=1 ; ac_runtime_checking=1 ;
386                         ac_tree_checking=1 ; ac_valgrind_checking= ;
387                         ac_types_checking=1 ;;
388         release)        ac_assert_checking=1 ; ac_checking= ; ac_df_checking= ;
389                         ac_fold_checking= ; ac_gc_checking= ;
390                         ac_gc_always_collect= ; ac_gimple_checking= ; ac_rtl_checking= ;
391                         ac_rtlflag_checking= ; ac_runtime_checking=1 ;
392                         ac_tree_checking= ; ac_valgrind_checking= ;
393                         ac_types_checking= ;;
394         # these enable particular checks
395         assert)         ac_assert_checking=1 ;;
396         df)             ac_df_checking=1 ;;
397         fold)           ac_fold_checking=1 ;;
398         gc)             ac_gc_checking=1 ;;
399         gcac)           ac_gc_always_collect=1 ;;
400         gimple)         ac_gimple_checking=1 ;;
401         misc)           ac_checking=1 ;;
402         rtl)            ac_rtl_checking=1 ;;
403         rtlflag)        ac_rtlflag_checking=1 ;;
404         runtime)        ac_runtime_checking=1 ;;
405         tree)           ac_tree_checking=1 ;;
406         types)          ac_types_checking=1 ;;
407         valgrind)       ac_valgrind_checking=1 ;;
408         *)      AC_MSG_ERROR(unknown check category $check) ;;
409         esac
410 done
411 IFS="$ac_save_IFS"
412
413 nocommon_flag=""
414 if test x$ac_checking != x ; then
415   AC_DEFINE(ENABLE_CHECKING, 1,
416 [Define if you want more run-time sanity checks.  This one gets a grab
417    bag of miscellaneous but relatively cheap checks.])
418   nocommon_flag=-fno-common
419 fi
420 AC_SUBST(nocommon_flag)
421 if test x$ac_df_checking != x ; then
422   AC_DEFINE(ENABLE_DF_CHECKING, 1,
423 [Define if you want more run-time sanity checks for dataflow.])
424 fi
425 if test x$ac_assert_checking != x ; then
426   AC_DEFINE(ENABLE_ASSERT_CHECKING, 1,
427 [Define if you want assertions enabled.  This is a cheap check.])
428 fi
429 if test x$ac_gimple_checking != x ; then
430   AC_DEFINE(ENABLE_GIMPLE_CHECKING, 1,
431 [Define if you want operations on GIMPLE (the basic data structure of
432 the high-level optimizers) to be checked for dynamic type safety at
433 runtime.  This is moderately expensive.])
434 fi
435 GCC_TARGET_TEMPLATE(ENABLE_RUNTIME_CHECKING)
436 if test x$ac_runtime_checking != x ; then
437   AC_DEFINE(ENABLE_RUNTIME_CHECKING, 1,
438 [Define if you want runtime assertions enabled.  This is a cheap check.])
439 fi
440 if test x$ac_tree_checking != x ; then
441   AC_DEFINE(ENABLE_TREE_CHECKING, 1,
442 [Define if you want all operations on trees (the basic data
443    structure of the front ends) to be checked for dynamic type safety
444    at runtime.  This is moderately expensive.  The tree browser debugging
445    routines will also be enabled by this option.
446    ])
447   TREEBROWSER=tree-browser.o
448 fi
449 if test x$ac_types_checking != x ; then
450   AC_DEFINE(ENABLE_TYPES_CHECKING, 1,
451 [Define if you want all gimple types to be verified after gimplifiation.
452    This is cheap.
453    ])
454 fi
455 AC_SUBST(TREEBROWSER)
456 if test x$ac_rtl_checking != x ; then
457   AC_DEFINE(ENABLE_RTL_CHECKING, 1,
458 [Define if you want all operations on RTL (the basic data structure
459    of the optimizer and back end) to be checked for dynamic type safety
460    at runtime.  This is quite expensive.])
461 fi
462 if test x$ac_rtlflag_checking != x ; then
463   AC_DEFINE(ENABLE_RTL_FLAG_CHECKING, 1,
464 [Define if you want RTL flag accesses to be checked against the RTL
465    codes that are supported for each access macro.  This is relatively
466    cheap.])
467 fi
468 if test x$ac_gc_checking != x ; then
469   AC_DEFINE(ENABLE_GC_CHECKING, 1,
470 [Define if you want the garbage collector to do object poisoning and
471    other memory allocation checks.  This is quite expensive.])
472 fi
473 if test x$ac_gc_always_collect != x ; then
474   AC_DEFINE(ENABLE_GC_ALWAYS_COLLECT, 1,
475 [Define if you want the garbage collector to operate in maximally
476    paranoid mode, validating the entire heap and collecting garbage at
477    every opportunity.  This is extremely expensive.])
478 fi
479 if test x$ac_fold_checking != x ; then
480   AC_DEFINE(ENABLE_FOLD_CHECKING, 1,
481 [Define if you want fold checked that it never destructs its argument.
482    This is quite expensive.])
483 fi
484 valgrind_path_defines=
485 valgrind_command=
486
487 dnl # This check AC_REQUIREs various stuff, so it *must not* be inside
488 dnl # an if statement.  This was the source of very frustrating bugs
489 dnl # in converting to autoconf 2.5x!
490 AC_CHECK_HEADER(valgrind.h, have_valgrind_h=yes, have_valgrind_h=no)
491
492 if test x$ac_valgrind_checking != x ; then
493   # It is certainly possible that there's valgrind but no valgrind.h.
494   # GCC relies on making annotations so we must have both.
495   AC_MSG_CHECKING(for VALGRIND_DISCARD in <valgrind/memcheck.h>)
496   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
497     [[#include <valgrind/memcheck.h>
498 #ifndef VALGRIND_DISCARD
499 #error VALGRIND_DISCARD not defined
500 #endif]])],
501   [gcc_cv_header_valgrind_memcheck_h=yes],
502   [gcc_cv_header_valgrind_memcheck_h=no])
503   AC_MSG_RESULT($gcc_cv_header_valgrind_memcheck_h)
504   AC_MSG_CHECKING(for VALGRIND_DISCARD in <memcheck.h>)
505   AC_PREPROC_IFELSE([AC_LANG_SOURCE(
506     [[#include <memcheck.h>
507 #ifndef VALGRIND_DISCARD
508 #error VALGRIND_DISCARD not defined
509 #endif]])],
510   [gcc_cv_header_memcheck_h=yes],
511   [gcc_cv_header_memcheck_h=no])
512   AC_MSG_RESULT($gcc_cv_header_memcheck_h)
513   AM_PATH_PROG_WITH_TEST(valgrind_path, valgrind,
514         [$ac_dir/$ac_word --version | grep valgrind- >/dev/null 2>&1])
515   if test "x$valgrind_path" = "x" \
516     || (test $have_valgrind_h = no \
517         && test $gcc_cv_header_memcheck_h = no \
518         && test $gcc_cv_header_valgrind_memcheck_h = no); then
519         AC_MSG_ERROR([*** Can't find both valgrind and valgrind/memcheck.h, memcheck.h or valgrind.h])
520   fi
521   valgrind_path_defines=-DVALGRIND_PATH='\"'$valgrind_path'\"'
522   valgrind_command="$valgrind_path -q"
523   AC_DEFINE(ENABLE_VALGRIND_CHECKING, 1,
524 [Define if you want to run subprograms and generated programs
525    through valgrind (a memory checker).  This is extremely expensive.])
526   if test $gcc_cv_header_valgrind_memcheck_h = yes; then
527     AC_DEFINE(HAVE_VALGRIND_MEMCHECK_H, 1,
528         [Define if valgrind's valgrind/memcheck.h header is installed.])
529   fi
530   if test $gcc_cv_header_memcheck_h = yes; then
531     AC_DEFINE(HAVE_MEMCHECK_H, 1,
532         [Define if valgrind's memcheck.h header is installed.])
533   fi
534 fi
535 AC_SUBST(valgrind_path_defines)
536 AC_SUBST(valgrind_command)
537
538 # Enable code coverage collection
539 AC_ARG_ENABLE(coverage,
540 [  --enable-coverage[=LEVEL]
541                           enable compiler's code coverage collection.
542                           Use to measure compiler performance and locate
543                           unused parts of the compiler. With LEVEL, specify
544                           optimization. Values are opt, noopt,
545                           default is noopt],
546 [case "${enableval}" in
547   yes|noopt)
548     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O0"
549     ;;
550   opt)
551     coverage_flags="-fprofile-arcs -ftest-coverage -frandom-seed=\$@ -O2"
552     ;;
553   no)
554     # a.k.a. --disable-coverage
555     coverage_flags=""
556     ;;
557   *)
558     AC_MSG_ERROR(unknown coverage setting $enableval)
559     ;;
560 esac],
561 [coverage_flags=""])
562 AC_SUBST(coverage_flags)
563
564 AC_ARG_ENABLE(gather-detailed-mem-stats, 
565 [  --enable-gather-detailed-mem-stats         enable detailed memory allocation stats gathering], [],
566 [enable_gather_detailed_mem_stats=no])
567 if test x$enable_gather_detailed_mem_stats = xyes ; then
568   AC_DEFINE(GATHER_STATISTICS, 1,
569         [Define to enable detailed memory allocation stats gathering.])
570 fi
571
572 # -------------------------------
573 # Miscenalleous configure options
574 # -------------------------------
575
576 # With stabs
577 AC_ARG_WITH(stabs,
578 [  --with-stabs            arrange to use stabs instead of host debug format],
579 stabs="$with_stabs",
580 stabs=no)
581
582 # Determine whether or not multilibs are enabled.
583 AC_ARG_ENABLE(multilib,
584 [  --enable-multilib       enable library support for multiple ABIs],
585 [], [enable_multilib=yes])
586 AC_SUBST(enable_multilib)
587
588 # Enable __cxa_atexit for C++.
589 AC_ARG_ENABLE(__cxa_atexit,
590 [  --enable-__cxa_atexit   enable __cxa_atexit for C++],
591 [], [])
592
593 # Enable C extension for decimal float if target supports it.
594 AC_ARG_ENABLE(decimal-float,
595 [  --enable-decimal-float={no,yes,bid,dpd}
596                         enable decimal float extension to C.  Selecting 'bid'
597                         or 'dpd' choses which decimal floating point format
598                         to use],
599 [
600   case $enable_decimal_float in
601     yes | no | bid | dpd) ;;
602     *) AC_MSG_ERROR(['$enable_decimal_float' is an invalid value for --enable-decimal-float.
603 Valid choices are 'yes', 'bid', 'dpd', and 'no'.]) ;;
604   esac
605 ],
606 [
607   case $target in
608     powerpc*-*-linux* | i?86*-*-linux* | x86_64*-*-linux*)
609       enable_decimal_float=yes
610       ;;
611     *)
612       AC_MSG_WARN(decimal float is not supported for this target, ignored)
613       enable_decimal_float=no
614       ;;
615   esac
616 ])
617
618 dfp=`if test $enable_decimal_float != no; then echo 1; else echo 0; fi`
619 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_FLOAT, $dfp,
620 [Define to 1 to enable decimal float extension to C.])
621
622 # x86's use BID format instead of DPD
623 case x$enable_decimal_float in
624   xyes)
625     case $target in
626       i?86*-*-linux* | x86_64*-*-linux*)
627         enable_decimal_float=bid
628         ;;
629       *)
630         enable_decimal_float=dpd
631         ;;
632     esac
633     ;;
634   xno)
635     # ENABLE_DECIMAL_FLOAT is set to 0. But we have to have proper
636     # dependency on libdecnumber.
637     enable_decimal_float=dpd
638     ;;
639 esac
640 AC_SUBST(enable_decimal_float)
641
642 bid=`if test $enable_decimal_float = bid; then echo 1; else echo 0; fi`
643 AC_DEFINE_UNQUOTED(ENABLE_DECIMAL_BID_FORMAT, $bid,
644 [Define to 1 to specify that we are using the BID decimal floating
645 point format instead of DPD])
646
647 # Enable C extension for fixed-point arithmetic.
648 AC_ARG_ENABLE(fixed-point,
649 [  --enable-fixed-point    enable fixed-point arithmetic extension to C],
650 [
651 ],
652 [
653   case $target in
654     mips*-*-*)
655       case $host in
656         mips*-sgi-irix*)
657           AC_MSG_WARN(fixed-point is not supported on IRIX, ignored)
658           enable_fixed_point=no
659           ;;
660         *)
661           enable_fixed_point=yes
662           ;;
663       esac
664       ;;
665     *)
666       AC_MSG_WARN(fixed-point is not supported for this target, ignored)
667       enable_fixed_point=no
668       ;;
669   esac
670 ])
671 AC_SUBST(enable_fixed_point)
672
673 fixedpoint=`if test $enable_fixed_point = yes; then echo 1; else echo 0; fi`
674 AC_DEFINE_UNQUOTED(ENABLE_FIXED_POINT, $fixedpoint,
675 [Define to 1 to enable fixed-point arithmetic extension to C.])
676
677 # Enable threads
678 # Pass with no value to take the default
679 # Pass with a value to specify a thread package
680 AC_ARG_ENABLE(threads,
681 [  --enable-threads        enable thread usage for target GCC
682   --enable-threads=LIB    use LIB thread package for target GCC],,
683 [enable_threads=''])
684
685 AC_ARG_ENABLE(tls,
686 [  --enable-tls            enable or disable generation of tls code
687                           overriding the assembler check for tls support],
688 [
689   case $enable_tls in
690     yes | no) ;;
691     *) AC_MSG_ERROR(['$enable_tls' is an invalid value for --enable-tls.
692 Valid choices are 'yes' and 'no'.]) ;;
693   esac
694 ], [enable_tls=''])
695
696 AC_ARG_ENABLE(objc-gc,
697 [  --enable-objc-gc       enable the use of Boehm's garbage collector with
698                           the GNU Objective-C runtime],
699 if test x$enable_objc_gc = xno; then
700         objc_boehm_gc=''
701 else
702         objc_boehm_gc=1
703 fi,
704 objc_boehm_gc='')
705
706 AC_ARG_WITH(dwarf2,
707 [  --with-dwarf2           force the default debug format to be DWARF 2],
708 dwarf2="$with_dwarf2",
709 dwarf2=no)
710
711 AC_ARG_ENABLE(shared,
712 [  --disable-shared        don't provide a shared libgcc],
713 [
714   case $enable_shared in
715   yes | no) ;;
716   *)
717     enable_shared=no
718     IFS="${IFS=         }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
719     for pkg in $enableval; do
720       if test "X$pkg" = "Xgcc" || test "X$pkg" = "Xlibgcc"; then
721         enable_shared=yes
722       fi
723     done
724     IFS="$ac_save_ifs"
725     ;;
726   esac
727 ], [enable_shared=yes])
728 AC_SUBST(enable_shared)
729
730 AC_ARG_WITH(build-sysroot, 
731   [  --with-build-sysroot=sysroot
732                           use sysroot as the system root during the build])
733
734 AC_ARG_WITH(sysroot,
735 [  --with-sysroot[=DIR] Search for usr/lib, usr/include, et al, within DIR.],
736 [
737  case ${with_sysroot} in
738  yes) TARGET_SYSTEM_ROOT='${exec_prefix}/${target_noncanonical}/sys-root' ;;
739  *) TARGET_SYSTEM_ROOT=$with_sysroot ;;
740  esac
741    
742  TARGET_SYSTEM_ROOT_DEFINE='-DTARGET_SYSTEM_ROOT=\"$(TARGET_SYSTEM_ROOT)\"'
743  CROSS_SYSTEM_HEADER_DIR='$(TARGET_SYSTEM_ROOT)$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
744         
745  if test "x$prefix" = xNONE; then
746   test_prefix=/usr/local
747  else
748   test_prefix=$prefix
749  fi
750  if test "x$exec_prefix" = xNONE; then
751   test_exec_prefix=$test_prefix
752  else
753   test_exec_prefix=$exec_prefix
754  fi
755  case ${TARGET_SYSTEM_ROOT} in
756  "${test_prefix}"|"${test_prefix}/"*|\
757  "${test_exec_prefix}"|"${test_exec_prefix}/"*|\
758  '${prefix}'|'${prefix}/'*|\
759  '${exec_prefix}'|'${exec_prefix}/'*)
760    t="$TARGET_SYSTEM_ROOT_DEFINE -DTARGET_SYSTEM_ROOT_RELOCATABLE"
761    TARGET_SYSTEM_ROOT_DEFINE="$t"
762    ;;
763  esac
764 ], [
765  TARGET_SYSTEM_ROOT=
766  TARGET_SYSTEM_ROOT_DEFINE=
767  CROSS_SYSTEM_HEADER_DIR='$(gcc_tooldir)/sys-include'
768 ])
769 AC_SUBST(TARGET_SYSTEM_ROOT)
770 AC_SUBST(TARGET_SYSTEM_ROOT_DEFINE)
771 AC_SUBST(CROSS_SYSTEM_HEADER_DIR)
772
773 # Build with intermodule optimisations
774 AC_ARG_ENABLE(intermodule,
775 [  --enable-intermodule    build the compiler in one step],
776 [case ${enable_intermodule} in
777   yes) onestep="-onestep";;
778   *) onestep="";;
779 esac],
780 [onestep=""])
781 AC_SUBST(onestep)
782
783 ACX_PKGVERSION([GCC])
784 ACX_BUGURL([http://gcc.gnu.org/bugs.html])
785
786 # Sanity check enable_languages in case someone does not run the toplevel
787 # configure # script.
788 AC_ARG_ENABLE(languages,
789 [  --enable-languages=LIST specify which front-ends to build],
790 [case ,${enable_languages}, in
791        ,,|,yes,)
792                 # go safe -- we cannot be much sure without the toplevel
793                 # configure's
794                 # analysis of which target libs are present and usable
795                 enable_languages=c
796                 ;;
797          *,all,*)
798                 AC_MSG_ERROR([only the toplevel supports --enable-languages=all])
799                 ;;
800         *,c,*)
801                 ;;
802         *)
803                 enable_languages=c,${enable_languages}
804                 ;;
805 esac],
806 [enable_languages=c])
807
808 # Used by documentation targets
809 AC_SUBST(datarootdir)
810 AC_SUBST(docdir)
811 AC_SUBST(htmldir)
812
813 # -------------------------
814 # Checks for other programs
815 # -------------------------
816
817 AC_PROG_MAKE_SET
818
819 # Find some useful tools
820 AC_PROG_AWK
821 # We need awk to create options.c and options.h.
822 # Bail out if it's missing.
823 case ${AWK} in
824   "") AC_MSG_ERROR([can't build without awk, bailing out]) ;;
825 esac
826
827 gcc_AC_PROG_LN_S
828 ACX_PROG_LN($LN_S)
829 AC_PROG_RANLIB
830 case "${host}" in
831 *-*-darwin*)
832   # By default, the Darwin ranlib will not treat common symbols as
833   # definitions when  building the archive table of contents.  Other 
834   # ranlibs do that; pass an option to the Darwin ranlib that makes
835   # it behave similarly.
836   ranlib_flags="-c" 
837   ;;
838 *)
839   ranlib_flags=""
840 esac
841 AC_SUBST(ranlib_flags)
842      
843 gcc_AC_PROG_INSTALL
844
845 # See if cmp has --ignore-initial.
846 gcc_AC_PROG_CMP_IGNORE_INITIAL
847
848 # See if we have the mktemp command.
849 AC_CHECK_PROG(have_mktemp_command, mktemp, yes, no)
850
851 # See if makeinfo has been installed and is modern enough
852 # that we can use it.
853 ACX_CHECK_PROG_VER(MAKEINFO, makeinfo, --version,
854   [GNU texinfo.* \([0-9][0-9.]*\)],
855   [4.[7-9]*|4.[1-9][0-9]*|[5-9]*|[1-9][0-9]*])
856 if test $gcc_cv_prog_makeinfo_modern = no; then
857   AC_MSG_WARN([
858 *** Makeinfo is missing or too old.
859 *** Info documentation will not be built.])
860   BUILD_INFO=
861 else
862   BUILD_INFO=info
863 fi
864 AC_SUBST(BUILD_INFO)
865
866 # Is pod2man recent enough to regenerate manpages?
867 AC_MSG_CHECKING([for recent Pod::Man])
868 if (perl -e 'use 1.10 Pod::Man') >/dev/null 2>&1; then
869   AC_MSG_RESULT(yes)
870   GENERATED_MANPAGES=generated-manpages
871 else
872   AC_MSG_RESULT(no)
873   GENERATED_MANPAGES=
874 fi
875 AC_SUBST(GENERATED_MANPAGES)
876
877 MISSING="${CONFIG_SHELL-/bin/sh} $ac_aux_dir/missing"
878
879 # How about lex?
880 dnl Don't use AC_PROG_LEX; we insist on flex.
881 dnl LEXLIB is not useful in gcc.
882 AC_CHECK_PROGS([FLEX], flex, [$MISSING flex])
883
884 # Bison?
885 AC_CHECK_PROGS([BISON], bison, [$MISSING bison])
886
887 # Binutils are not build modules, unlike bison/flex/makeinfo.  So we
888 # check for build == host before using them.
889
890 # NM
891 if test x${build} = x${host} && test -f $srcdir/../binutils/nm.c \
892   && test -d ../binutils ; then
893   NM='$(objdir)/../binutils/nm-new'
894 else
895   AC_CHECK_PROG(NM, nm, nm, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing nm)
896 fi
897
898 # AR
899 if test x${build} = x${host} && test -f $srcdir/../binutils/ar.c \
900   && test -d ../binutils ; then
901   AR='$(objdir)/../binutils/ar'
902 else
903   AC_CHECK_PROG(AR, ar, ar, ${CONFIG_SHELL-/bin/sh} ${srcdir}/../missing ar)
904 fi
905
906
907 # --------------------
908 # Checks for C headers
909 # --------------------
910
911 # Need to reject headers which give warnings, so that the -Werror bootstrap
912 # works later. *sigh*  This needs to come before all header checks.
913 AC_PROG_CPP_WERROR
914
915 AC_HEADER_STDC
916 AC_HEADER_TIME
917 ACX_HEADER_STRING
918 AC_HEADER_SYS_WAIT
919 AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h iconv.h \
920                  fcntl.h unistd.h sys/file.h sys/time.h sys/mman.h \
921                  sys/resource.h sys/param.h sys/times.h sys/stat.h \
922                  direct.h malloc.h langinfo.h ldfcn.h locale.h wchar.h)
923
924 # Check for thread headers.
925 AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
926 AC_CHECK_HEADER(pthread.h, [have_pthread_h=yes], [have_pthread_h=])
927
928 # These tests can't be done till we know if we have limits.h.
929 gcc_AC_C_CHAR_BIT
930 AC_C_BIGENDIAN
931
932 # --------
933 # UNSORTED
934 # --------
935
936
937 # These libraries may be used by collect2.
938 # We may need a special search path to get them linked.
939 AC_CACHE_CHECK(for collect2 libraries, gcc_cv_collect2_libs,
940 [save_LIBS="$LIBS"
941 for libs in '' -lld -lmld \
942                 '-L/usr/lib/cmplrs/cc2.11 -lmld' \
943                 '-L/usr/lib/cmplrs/cc3.11 -lmld'
944 do
945         LIBS="$libs"
946         AC_TRY_LINK_FUNC(ldopen,
947                 [gcc_cv_collect2_libs="$libs"; break])
948 done
949 LIBS="$save_LIBS"
950 test -z "$gcc_cv_collect2_libs" && gcc_cv_collect2_libs='none required'])
951 case $gcc_cv_collect2_libs in
952         "none required")        ;;
953         *)      COLLECT2_LIBS=$gcc_cv_collect2_libs ;;
954 esac
955 AC_SUBST(COLLECT2_LIBS)
956
957 # When building Ada code on Alpha, we need exc_resume which is usually in
958 # -lexc.  So test for it.
959 save_LIBS="$LIBS"
960 LIBS=
961 AC_SEARCH_LIBS(exc_resume, exc)
962 GNAT_LIBEXC="$LIBS"
963 LIBS="$save_LIBS"
964 AC_SUBST(GNAT_LIBEXC)
965
966 # Some systems put ldexp and frexp in libm instead of libc; assume
967 # they're both in the same place.  jcf-dump needs them.
968 save_LIBS="$LIBS"
969 LIBS=
970 AC_SEARCH_LIBS(ldexp, m)
971 LDEXP_LIB="$LIBS"
972 LIBS="$save_LIBS"
973 AC_SUBST(LDEXP_LIB)
974
975 # Use <inttypes.h> only if it exists,
976 # doesn't clash with <sys/types.h>, and declares intmax_t.
977 AC_MSG_CHECKING(for inttypes.h)
978 AC_CACHE_VAL(gcc_cv_header_inttypes_h,
979 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
980 [[#include <sys/types.h>
981 #include <inttypes.h>]],
982   [[intmax_t i = -1;]])],
983   [gcc_cv_header_inttypes_h=yes],
984   [gcc_cv_header_inttypes_h=no])])
985 AC_MSG_RESULT($gcc_cv_header_inttypes_h)
986 if test $gcc_cv_header_inttypes_h = yes; then
987   AC_DEFINE(HAVE_INTTYPES_H, 1,
988         [Define if you have a working <inttypes.h> header file.])
989 fi
990
991 dnl Disabled until we have a complete test for buggy enum bitfields.
992 dnl gcc_AC_C_ENUM_BF_UNSIGNED
993
994 define(gcc_UNLOCKED_FUNCS, clearerr_unlocked feof_unlocked dnl
995   ferror_unlocked fflush_unlocked fgetc_unlocked fgets_unlocked dnl
996   fileno_unlocked fprintf_unlocked fputc_unlocked fputs_unlocked dnl
997   fread_unlocked fwrite_unlocked getchar_unlocked getc_unlocked dnl
998   putchar_unlocked putc_unlocked)
999 AC_CHECK_FUNCS(times clock kill getrlimit setrlimit atoll atoq \
1000         sysconf strsignal getrusage nl_langinfo \
1001         gettimeofday mbstowcs wcswidth mmap mincore setlocale \
1002         gcc_UNLOCKED_FUNCS)
1003
1004 if test x$ac_cv_func_mbstowcs = xyes; then
1005   AC_CACHE_CHECK(whether mbstowcs works, gcc_cv_func_mbstowcs_works,
1006 [    AC_RUN_IFELSE([AC_LANG_SOURCE([[#include <stdlib.h>
1007 int main()
1008 {
1009   mbstowcs(0, "", 0);
1010   return 0;
1011 }]])],
1012     [gcc_cv_func_mbstowcs_works=yes],
1013     [gcc_cv_func_mbstowcs_works=no],
1014     [gcc_cv_func_mbstowcs_works=yes])])
1015   if test x$gcc_cv_func_mbstowcs_works = xyes; then
1016     AC_DEFINE(HAVE_WORKING_MBSTOWCS, 1,
1017   [Define this macro if mbstowcs does not crash when its
1018    first argument is NULL.])
1019   fi
1020 fi
1021
1022 AC_CHECK_TYPE(ssize_t, int)
1023 AC_CHECK_TYPE(caddr_t, char *)
1024
1025 gcc_AC_FUNC_MMAP_BLACKLIST
1026
1027 case "${host}" in
1028 *-*-*vms*)
1029   # Under VMS, vfork works very differently than on Unix. The standard test 
1030   # won't work, and it isn't easily adaptable. It makes more sense to
1031   # just force it.
1032   ac_cv_func_vfork_works=yes
1033   ;;
1034 esac
1035 AC_FUNC_FORK
1036
1037 AM_ICONV
1038 # Until we have in-tree GNU iconv:
1039 LIBICONV_DEP=
1040 AC_SUBST(LIBICONV_DEP)
1041
1042 AM_LC_MESSAGES
1043
1044 AM_LANGINFO_CODESET
1045
1046 # We will need to find libiberty.h and ansidecl.h
1047 saved_CFLAGS="$CFLAGS"
1048 CFLAGS="$CFLAGS -I${srcdir} -I${srcdir}/../include"
1049 gcc_AC_CHECK_DECLS(getenv atol asprintf sbrk abort atof getcwd getwd \
1050         strsignal strstr strverscmp \
1051         errno snprintf vsnprintf vasprintf malloc realloc calloc \
1052         free basename getopt clock getpagesize gcc_UNLOCKED_FUNCS, , ,[
1053 #include "ansidecl.h"
1054 #include "system.h"])
1055
1056 gcc_AC_CHECK_DECLS(getrlimit setrlimit getrusage, , ,[
1057 #include "ansidecl.h"
1058 #include "system.h"
1059 #ifdef HAVE_SYS_RESOURCE_H
1060 #include <sys/resource.h>
1061 #endif
1062 ])
1063
1064 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1065 #include "ansidecl.h"
1066 #include "system.h"
1067 #ifdef HAVE_SYS_RESOURCE_H
1068 #include <sys/resource.h>
1069 #endif
1070 ]], [[rlim_t l = 0;]])],[],[AC_DEFINE([rlim_t],[long],
1071 [Define to `long' if <sys/resource.h> doesn't define.])])
1072
1073 # On AIX 5.2, <ldfcn.h> conflicts with <fcntl.h>, as both define incompatible
1074 # FREAD and FWRITE macros.  Fortunately, for GCC's single usage of ldgetname
1075 # in collect2.c, <fcntl.h> isn't visible, but the configure test below needs
1076 # to undef these macros to get the correct value for HAVE_DECL_LDGETNAME.
1077 gcc_AC_CHECK_DECLS(ldgetname, , ,[
1078 #include "ansidecl.h"
1079 #include "system.h"
1080 #ifdef HAVE_LDFCN_H
1081 #undef FREAD
1082 #undef FWRITE
1083 #include <ldfcn.h>
1084 #endif
1085 ])
1086
1087 gcc_AC_CHECK_DECLS(times, , ,[
1088 #include "ansidecl.h"
1089 #include "system.h"
1090 #ifdef HAVE_SYS_TIMES_H
1091 #include <sys/times.h>
1092 #endif
1093 ])
1094
1095 gcc_AC_CHECK_DECLS(sigaltstack, , ,[
1096 #include "ansidecl.h"
1097 #include "system.h"
1098 #include <signal.h>
1099 ])
1100
1101 # More time-related stuff.
1102 AC_CACHE_CHECK(for struct tms, ac_cv_struct_tms, [
1103 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1104 #include "ansidecl.h"
1105 #include "system.h"
1106 #ifdef HAVE_SYS_TIMES_H
1107 #include <sys/times.h>
1108 #endif
1109 ]], [[struct tms tms;]])],[ac_cv_struct_tms=yes],[ac_cv_struct_tms=no])])
1110 if test $ac_cv_struct_tms = yes; then
1111   AC_DEFINE(HAVE_STRUCT_TMS, 1,
1112   [Define if <sys/times.h> defines struct tms.])
1113 fi
1114
1115 # use gcc_cv_* here because this doesn't match the behavior of AC_CHECK_TYPE.
1116 # revisit after autoconf 2.50.
1117 AC_CACHE_CHECK(for clock_t, gcc_cv_type_clock_t, [
1118 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
1119 #include "ansidecl.h"
1120 #include "system.h"
1121 ]], [[clock_t x;]])],[gcc_cv_type_clock_t=yes],[gcc_cv_type_clock_t=no])])
1122 if test $gcc_cv_type_clock_t = yes; then
1123   AC_DEFINE(HAVE_CLOCK_T, 1,
1124   [Define if <time.h> defines clock_t.])
1125 fi
1126
1127 # Restore CFLAGS from before the gcc_AC_NEED_DECLARATIONS tests.
1128 CFLAGS="$saved_CFLAGS"
1129
1130 gcc_AC_INITFINI_ARRAY
1131
1132 # mkdir takes a single argument on some systems. 
1133 gcc_AC_FUNC_MKDIR_TAKES_ONE_ARG
1134
1135 # File extensions
1136 manext='.1'
1137 objext='.o'
1138 AC_SUBST(manext)
1139 AC_SUBST(objext)
1140
1141 # With Setjmp/Longjmp based exception handling.
1142 AC_ARG_ENABLE(sjlj-exceptions,
1143 [  --enable-sjlj-exceptions
1144                           arrange to use setjmp/longjmp exception handling],
1145 [case $target in
1146   *-*-hpux10*)
1147     if test $enableval != yes; then
1148       AC_MSG_WARN([dwarf2 exceptions not supported, sjlj exceptions forced])
1149       enableval=yes
1150     fi
1151     ;;
1152 esac
1153 force_sjlj_exceptions=yes],
1154 [case $target in
1155   *-*-hpux10*)
1156     force_sjlj_exceptions=yes
1157     enableval=yes
1158     ;;
1159   *)
1160     force_sjlj_exceptions=no
1161     ;;
1162 esac])
1163 if test $force_sjlj_exceptions = yes; then
1164   sjlj=`if test $enableval = yes; then echo 1; else echo 0; fi`
1165   AC_DEFINE_UNQUOTED(CONFIG_SJLJ_EXCEPTIONS, $sjlj,
1166     [Define 0/1 to force the choice for exception handling model.])
1167 fi
1168
1169 # For platforms with the unwind ABI which includes an unwind library,
1170 # libunwind, we can choose to use the system libunwind.
1171 # config.gcc also contains tests of with_system_libunwind.
1172 GCC_CHECK_UNWIND_GETIPINFO
1173
1174 # --------------------------------------------------------
1175 # Build, host, and target specific configuration fragments
1176 # --------------------------------------------------------
1177
1178 # Collect build-machine-specific information.
1179 . ${srcdir}/config.build
1180
1181 # Collect host-machine-specific information.
1182 . ${srcdir}/config.host
1183
1184 target_gtfiles=
1185
1186 # Collect target-machine-specific information.
1187 . ${srcdir}/config.gcc
1188
1189 extra_objs="${host_extra_objs} ${extra_objs}"
1190 extra_gcc_objs="${host_extra_gcc_objs} ${extra_gcc_objs}"
1191
1192 # Default the target-machine variables that were not explicitly set.
1193 if test x"$tm_file" = x
1194 then tm_file=$cpu_type/$cpu_type.h; fi
1195
1196 if test x"$extra_headers" = x
1197 then extra_headers=; fi
1198
1199 if test x$md_file = x
1200 then md_file=$cpu_type/$cpu_type.md; fi
1201
1202 if test x$out_file = x
1203 then out_file=$cpu_type/$cpu_type.c; fi
1204
1205 if test x"$tmake_file" = x
1206 then tmake_file=$cpu_type/t-$cpu_type
1207 fi
1208
1209 if test x"$dwarf2" = xyes
1210 then tm_file="$tm_file tm-dwarf2.h"
1211 fi
1212
1213 # Say what files are being used for the output code and MD file.
1214 echo "Using \`$srcdir/config/$out_file' for machine-specific logic."
1215 echo "Using \`$srcdir/config/$md_file' as machine description file."
1216
1217 # If any of the xm_file variables contain nonexistent files, warn
1218 # about them and drop them.
1219
1220 bx=
1221 for x in $build_xm_file; do
1222   if    test -f $srcdir/config/$x
1223   then      bx="$bx $x"
1224   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1225   fi
1226 done
1227 build_xm_file="$bx"
1228
1229 hx=
1230 for x in $host_xm_file; do
1231   if    test -f $srcdir/config/$x
1232   then      hx="$hx $x"
1233   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1234   fi
1235 done
1236 host_xm_file="$hx"
1237
1238 tx=
1239 for x in $xm_file; do
1240   if    test -f $srcdir/config/$x
1241   then      tx="$tx $x"
1242   else      AC_MSG_WARN($srcdir/config/$x does not exist.)
1243   fi
1244 done
1245 xm_file="$tx"
1246
1247 count=a
1248 for f in $tm_file; do
1249         count=${count}x
1250 done
1251 if test $count = ax; then
1252         echo "Using \`$srcdir/config/$tm_file' as target machine macro file."
1253 else
1254         echo "Using the following target machine macro files:"
1255         for f in $tm_file; do
1256                 echo "  $srcdir/config/$f"
1257         done
1258 fi
1259
1260 if test x$need_64bit_hwint = xyes; then
1261         AC_DEFINE(NEED_64BIT_HOST_WIDE_INT, 1,
1262 [Define to 1 if HOST_WIDE_INT must be 64 bits wide (see hwint.h).])
1263 fi
1264
1265 if test x$use_long_long_for_widest_fast_int = xyes; then
1266         AC_DEFINE(USE_LONG_LONG_FOR_WIDEST_FAST_INT, 1,
1267 [Define to 1 if the 'long long' (or '__int64') is wider than 'long' but still
1268 efficiently supported by the host hardware.])
1269 fi
1270
1271 count=a
1272 for f in $host_xm_file; do
1273         count=${count}x
1274 done
1275 if test $count = a; then
1276         :
1277 elif test $count = ax; then
1278         echo "Using \`$srcdir/config/$host_xm_file' as host machine macro file."
1279 else
1280         echo "Using the following host machine macro files:"
1281         for f in $host_xm_file; do
1282                 echo "  $srcdir/config/$f"
1283         done
1284 fi
1285 echo "Using ${out_host_hook_obj} for host machine hooks."
1286
1287 if test "$host_xm_file" != "$build_xm_file"; then
1288         count=a
1289         for f in $build_xm_file; do
1290                 count=${count}x
1291         done
1292         if test $count = a; then
1293                 :
1294         elif test $count = ax; then
1295                 echo "Using \`$srcdir/config/$build_xm_file' as build machine macro file."
1296         else
1297                 echo "Using the following build machine macro files:"
1298                 for f in $build_xm_file; do
1299                         echo "  $srcdir/config/$f"
1300                 done
1301         fi
1302 fi
1303
1304 case ${host} in
1305   powerpc*-*-darwin*)
1306     AC_CACHE_CHECK([whether mcontext_t fields have underscores],
1307       gcc_cv_mcontext_underscores,
1308       AC_COMPILE_IFELSE([
1309 #include <sys/cdefs.h>
1310 #include <sys/signal.h>
1311 #include <ucontext.h>
1312 int main() { mcontext_t m; if (m->ss.srr0) return 0; return 0; }
1313 ],
1314         gcc_cv_mcontext_underscores=no, gcc_cv_mcontext_underscores=yes))
1315       if test $gcc_cv_mcontext_underscores = yes; then
1316         AC_DEFINE(HAS_MCONTEXT_T_UNDERSCORES,,dnl
1317           [mcontext_t fields start with __])
1318       fi
1319     ;;
1320 esac
1321
1322 # ---------
1323 # Threading
1324 # ---------
1325
1326 # Check if a valid thread package
1327 case ${enable_threads} in
1328   "" | no)
1329     # No threads
1330     target_thread_file='single'
1331     ;;
1332   yes)
1333     # default
1334     target_thread_file='single'
1335     ;;
1336   aix | dce | gnat | irix | posix | posix95 | rtems | \
1337   single | solaris | vxworks | win32 | mipssde)
1338     target_thread_file=${enable_threads}
1339     ;;
1340   *)
1341     echo "${enable_threads} is an unknown thread package" 1>&2
1342     exit 1
1343     ;;
1344 esac
1345
1346 if test x${thread_file} = x; then
1347   # No thread file set by target-specific clauses in config.gcc,
1348   # so use file chosen by default logic above
1349   thread_file=${target_thread_file}
1350 fi
1351
1352 # Make gthr-default.h if we have a thread file.
1353 gthread_flags=
1354 if test $thread_file != single; then
1355   echo "#include \"gthr-${thread_file}.h\"" > gthr-default.h-t
1356   if diff gthr-default.h-t gthr-default.h 2>/dev/null; then
1357     rm -f gthr-default.h-t
1358   else
1359     mv -f gthr-default.h-t gthr-default.h
1360   fi
1361   gthread_flags=-DHAVE_GTHR_DEFAULT
1362 fi
1363 AC_SUBST(gthread_flags)
1364
1365 # --------
1366 # UNSORTED
1367 # --------
1368
1369 use_cxa_atexit=no
1370 if test x$enable___cxa_atexit = xyes || \
1371    test x$enable___cxa_atexit = x -a x$default_use_cxa_atexit = xyes; then
1372   if test x$host = x$target; then
1373     case $host in
1374       # mingw32 doesn't have __cxa_atexit but uses atexit registration
1375       # keyed to flag_use_cxa_atexit
1376       *-*-mingw32*)
1377         use_cxa_atexit=yes
1378         ;;
1379       *)
1380         AC_CHECK_FUNC(__cxa_atexit,[use_cxa_atexit=yes],
1381           [echo "__cxa_atexit can't be enabled on this target"])
1382         ;;
1383     esac
1384   else
1385     # We can't check for __cxa_atexit when building a cross, so assume
1386     # it is available 
1387     use_cxa_atexit=yes
1388   fi
1389   if test x$use_cxa_atexit = xyes; then
1390     AC_DEFINE(DEFAULT_USE_CXA_ATEXIT, 2,
1391       [Define if you want to use __cxa_atexit, rather than atexit, to
1392       register C++ destructors for local statics and global objects.
1393       This is essential for fully standards-compliant handling of
1394       destructors, but requires __cxa_atexit in libc.])
1395   fi
1396 fi
1397
1398 # Look for a file containing extra machine modes.
1399 if test -n "$extra_modes" && test -f $srcdir/config/$extra_modes; then
1400   extra_modes_file='$(srcdir)'/config/${extra_modes}
1401   AC_SUBST(extra_modes_file)
1402   AC_DEFINE_UNQUOTED(EXTRA_MODES_FILE, "config/$extra_modes",
1403   [Define to the name of a file containing a list of extra machine modes
1404    for this architecture.])
1405 fi
1406
1407 # Convert extra_options into a form suitable for Makefile use.
1408 extra_opt_files=
1409 for f in $extra_options; do
1410   extra_opt_files="$extra_opt_files \$(srcdir)/config/$f"
1411 done
1412 AC_SUBST(extra_opt_files)
1413
1414 # auto-host.h is the file containing items generated by autoconf and is
1415 # the first file included by config.h.
1416 # If host=build, it is correct to have bconfig include auto-host.h
1417 # as well.  If host!=build, we are in error and need to do more 
1418 # work to find out the build config parameters.
1419 if test x$host = x$build
1420 then
1421         build_auto=auto-host.h
1422 else
1423         # We create a subdir, then run autoconf in the subdir.
1424         # To prevent recursion we set host and build for the new
1425         # invocation of configure to the build for this invocation
1426         # of configure. 
1427         tempdir=build.$$
1428         rm -rf $tempdir
1429         mkdir $tempdir
1430         cd $tempdir
1431         case ${srcdir} in
1432         /* | [A-Za-z]:[\\/]* ) realsrcdir=${srcdir};;
1433         *) realsrcdir=../${srcdir};;
1434         esac
1435         saved_CFLAGS="${CFLAGS}"
1436         CC="${CC_FOR_BUILD}" CFLAGS="${CFLAGS_FOR_BUILD}" \
1437         LDFLAGS="${LDFLAGS_FOR_BUILD}" \
1438         ${realsrcdir}/configure \
1439                 --enable-languages=${enable_languages-all} \
1440                 --target=$target_alias --host=$build_alias --build=$build_alias
1441         CFLAGS="${saved_CFLAGS}"
1442
1443         # We just finished tests for the build machine, so rename
1444         # the file auto-build.h in the gcc directory.
1445         mv auto-host.h ../auto-build.h
1446         cd ..
1447         rm -rf $tempdir
1448         build_auto=auto-build.h
1449 fi
1450 AC_SUBST(build_subdir)
1451
1452 tm_file="${tm_file} defaults.h"
1453 tm_p_file="${tm_p_file} tm-preds.h"
1454 host_xm_file="auto-host.h ansidecl.h ${host_xm_file}"
1455 build_xm_file="${build_auto} ansidecl.h ${build_xm_file}"
1456 # We don't want ansidecl.h in target files, write code there in ISO/GNU C.
1457 # put this back in temporarily.
1458 xm_file="auto-host.h ansidecl.h ${xm_file}"
1459
1460 # --------
1461 # UNSORTED
1462 # --------
1463
1464 changequote(,)dnl
1465 # Compile in configure arguments.
1466 if test -f configargs.h ; then
1467         # Being re-configured.
1468         gcc_config_arguments=`grep configuration_arguments configargs.h | sed -e 's/.*"\([^"]*\)".*/\1/'`
1469         gcc_config_arguments="$gcc_config_arguments : (reconfigured) $TOPLEVEL_CONFIGURE_ARGUMENTS"
1470 else
1471         gcc_config_arguments="$TOPLEVEL_CONFIGURE_ARGUMENTS"
1472 fi
1473
1474 # Double all backslashes and backslash all quotes to turn
1475 # gcc_config_arguments into a C string.
1476 sed -e 's/\\/\\\\/g; s/"/\\"/g' <<EOF >conftest.out
1477 $gcc_config_arguments
1478 EOF
1479 gcc_config_arguments_str=`cat conftest.out`
1480 rm -f conftest.out
1481
1482 cat > configargs.h <<EOF
1483 /* Generated automatically. */
1484 static const char configuration_arguments[] = "$gcc_config_arguments_str";
1485 static const char thread_model[] = "$thread_file";
1486
1487 static const struct {
1488   const char *name, *value;
1489 } configure_default_options[] = $configure_default_options;
1490 EOF
1491 changequote([,])dnl
1492
1493 # Internationalization
1494 ZW_GNU_GETTEXT_SISTER_DIR
1495
1496 # If LIBINTL contains LIBICONV, then clear LIBICONV so we don't get
1497 # -liconv on the link line twice.
1498 case "$LIBINTL" in *$LIBICONV*)
1499         LIBICONV= ;;
1500 esac
1501
1502 AC_ARG_ENABLE(secureplt,
1503 [  --enable-secureplt      enable -msecure-plt by default for PowerPC],
1504 [], [])
1505
1506 AC_ARG_ENABLE(cld,
1507 [  --enable-cld            enable -mcld by default for 32bit x86], [],
1508 [enable_cld=no])
1509
1510 # Windows32 Registry support for specifying GCC installation paths.
1511 AC_ARG_ENABLE(win32-registry,
1512 [  --disable-win32-registry
1513                           disable lookup of installation paths in the
1514                           Registry on Windows hosts
1515   --enable-win32-registry enable registry lookup (default)
1516   --enable-win32-registry=KEY
1517                           use KEY instead of GCC version as the last portion
1518                           of the registry key],,)
1519
1520 case $host_os in
1521   win32 | pe | cygwin* | mingw32* | uwin*)
1522     if test "x$enable_win32_registry" != xno; then
1523       AC_SEARCH_LIBS(RegOpenKeyExA, advapi32,, [enable_win32_registry=no])
1524     fi
1525
1526     if test "x$enable_win32_registry" != xno; then
1527       AC_DEFINE(ENABLE_WIN32_REGISTRY, 1,
1528   [Define to 1 if installation paths should be looked up in the Windows
1529    Registry. Ignored on non-Windows hosts.])
1530
1531       if test "x$enable_win32_registry" != xyes \
1532          && test "x$enable_win32_registry" != x; then
1533         AC_DEFINE_UNQUOTED(WIN32_REGISTRY_KEY, "$enable_win32_registry",
1534   [Define to be the last component of the Windows registry key under which
1535    to look for installation paths.  The full key used will be 
1536    HKEY_LOCAL_MACHINE/SOFTWARE/Free Software Foundation/{WIN32_REGISTRY_KEY}.
1537    The default is the GCC version number.])
1538       fi
1539     fi
1540   ;;
1541 esac
1542
1543 # Get an absolute path to the GCC top-level source directory
1544 holddir=`${PWDCMD-pwd}`
1545 cd $srcdir
1546 topdir=`${PWDCMD-pwd}`
1547 cd $holddir
1548
1549 # Conditionalize the makefile for this host machine.
1550 xmake_file=
1551 for f in ${host_xmake_file}
1552 do
1553         if test -f ${srcdir}/config/$f
1554         then
1555                 xmake_file="${xmake_file} \$(srcdir)/config/$f"
1556         fi
1557 done
1558
1559 # Conditionalize the makefile for this target machine.
1560 tmake_file_=
1561 for f in ${tmake_file}
1562 do
1563         if test -f ${srcdir}/config/$f
1564         then
1565                 tmake_file_="${tmake_file_} \$(srcdir)/config/$f"
1566         fi
1567 done
1568 tmake_file="${tmake_file_}"
1569
1570 out_object_file=`basename $out_file .c`.o
1571
1572 tm_file_list="options.h"
1573 tm_include_list="options.h"
1574 for f in $tm_file; do
1575   case $f in
1576     ./* )
1577        f=`echo $f | sed 's/^..//'`
1578        tm_file_list="${tm_file_list} $f"
1579        tm_include_list="${tm_include_list} $f"
1580        ;;
1581     defaults.h )
1582        tm_file_list="${tm_file_list} \$(srcdir)/$f"
1583        tm_include_list="${tm_include_list} $f"
1584        ;;
1585     * )
1586        tm_file_list="${tm_file_list} \$(srcdir)/config/$f"
1587        tm_include_list="${tm_include_list} config/$f"
1588        ;;
1589   esac
1590 done
1591
1592 tm_p_file_list=
1593 tm_p_include_list=
1594 for f in $tm_p_file; do
1595   case $f in
1596     tm-preds.h )
1597        tm_p_file_list="${tm_p_file_list} $f"
1598        tm_p_include_list="${tm_p_include_list} $f"
1599        ;;
1600     * )
1601        tm_p_file_list="${tm_p_file_list} \$(srcdir)/config/$f"
1602        tm_p_include_list="${tm_p_include_list} config/$f"
1603   esac
1604 done
1605
1606 xm_file_list=
1607 xm_include_list=
1608 for f in $xm_file; do
1609   case $f in
1610     ansidecl.h )
1611        xm_file_list="${xm_file_list} \$(srcdir)/../include/$f"
1612        xm_include_list="${xm_include_list} $f"
1613        ;;
1614     auto-host.h )
1615        xm_file_list="${xm_file_list} $f"
1616        xm_include_list="${xm_include_list} $f"
1617        ;;
1618     * )
1619        xm_file_list="${xm_file_list} \$(srcdir)/config/$f"
1620        xm_include_list="${xm_include_list} config/$f"
1621        ;;
1622   esac
1623 done
1624
1625 host_xm_file_list=
1626 host_xm_include_list=
1627 for f in $host_xm_file; do
1628   case $f in
1629     ansidecl.h )
1630        host_xm_file_list="${host_xm_file_list} \$(srcdir)/../include/$f"
1631        host_xm_include_list="${host_xm_include_list} $f"
1632        ;;
1633     auto-host.h )
1634        host_xm_file_list="${host_xm_file_list} $f"
1635        host_xm_include_list="${host_xm_include_list} $f"
1636        ;;
1637     * )
1638        host_xm_file_list="${host_xm_file_list} \$(srcdir)/config/$f"
1639        host_xm_include_list="${host_xm_include_list} config/$f"
1640        ;;
1641   esac
1642 done
1643
1644 build_xm_file_list=
1645 for f in $build_xm_file; do
1646   case $f in
1647     ansidecl.h )
1648        build_xm_file_list="${build_xm_file_list} \$(srcdir)/../include/$f"
1649        build_xm_include_list="${build_xm_include_list} $f"
1650        ;;
1651     auto-build.h | auto-host.h )
1652        build_xm_file_list="${build_xm_file_list} $f"
1653        build_xm_include_list="${build_xm_include_list} $f"
1654        ;;
1655     * )
1656        build_xm_file_list="${build_xm_file_list} \$(srcdir)/config/$f"
1657        build_xm_include_list="${build_xm_include_list} config/$f"
1658        ;;
1659   esac
1660 done
1661
1662 # Define macro CROSS_DIRECTORY_STRUCTURE in compilation if this is a
1663 # cross-compiler which does not use the native headers and libraries.
1664 # Also use all.cross instead of all.internal and adjust SYSTEM_HEADER_DIR.
1665 CROSS=                                          AC_SUBST(CROSS)
1666 ALL=all.internal                                AC_SUBST(ALL)
1667 SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)' AC_SUBST(SYSTEM_HEADER_DIR)
1668
1669 if test "x$with_build_sysroot" != x; then
1670   build_system_header_dir=$with_build_sysroot'$${sysroot_headers_suffix}$(NATIVE_SYSTEM_HEADER_DIR)'
1671 else
1672   # This value is used, even on a native system, because 
1673   # CROSS_SYSTEM_HEADER_DIR is just 
1674   # $(TARGET_SYSTEM_ROOT)$(NATIVE_SYSTEM_HEADER_DIR).
1675   build_system_header_dir='$(CROSS_SYSTEM_HEADER_DIR)'
1676 fi
1677
1678 if test x$host != x$target
1679 then
1680         CROSS="-DCROSS_DIRECTORY_STRUCTURE"
1681         ALL=all.cross
1682         SYSTEM_HEADER_DIR=$build_system_header_dir
1683         case "$host","$target" in
1684         # Darwin crosses can use the host system's libraries and headers,
1685         # because of the fat library support.  Of course, it must be the
1686         # same version of Darwin on both sides.  Allow the user to
1687         # just say --target=foo-darwin without a version number to mean
1688         # "the version on this system".
1689             *-*-darwin*,*-*-darwin*)
1690                 hostos=`echo $host | sed 's/.*-darwin/darwin/'`
1691                 targetos=`echo $target | sed 's/.*-darwin/darwin/'`
1692                 if test $hostos = $targetos -o $targetos = darwin ; then
1693                     CROSS=
1694                     SYSTEM_HEADER_DIR='$(NATIVE_SYSTEM_HEADER_DIR)'
1695                     with_headers=yes
1696                 fi
1697                 ;;
1698
1699             i?86-*-*,x86_64-*-* \
1700             | powerpc*-*-*,powerpc64*-*-*)
1701                 CROSS="$CROSS -DNATIVE_CROSS" ;;
1702         esac
1703 elif test "x$TARGET_SYSTEM_ROOT" != x; then
1704         SYSTEM_HEADER_DIR=$build_system_header_dir 
1705 fi
1706
1707 # If this is a cross-compiler that does not
1708 # have its own set of headers then define
1709 # inhibit_libc
1710
1711 # If this is using newlib, without having the headers available now,
1712 # then define inhibit_libc in LIBGCC2_CFLAGS.
1713 # This prevents libgcc2 from containing any code which requires libc
1714 # support.
1715 : ${inhibit_libc=false}
1716 if { { test x$host != x$target && test "x$with_sysroot" = x ; } ||
1717        test x$with_newlib = xyes ; } &&
1718      { test "x$with_headers" = x || test "x$with_headers" = xno ; } ; then
1719        inhibit_libc=true
1720 fi
1721 AC_SUBST(inhibit_libc)
1722
1723 # When building gcc with a cross-compiler, we need to adjust things so
1724 # that the generator programs are still built with the native compiler.
1725 # Also, we cannot run fixincludes.
1726
1727 # These are the normal (build=host) settings:
1728 CC_FOR_BUILD='$(CC)'            AC_SUBST(CC_FOR_BUILD)
1729 BUILD_CFLAGS='$(ALL_CFLAGS)'    AC_SUBST(BUILD_CFLAGS)
1730 BUILD_LDFLAGS='$(LDFLAGS)'      AC_SUBST(BUILD_LDFLAGS)
1731 STMP_FIXINC=stmp-fixinc         AC_SUBST(STMP_FIXINC)
1732
1733 # And these apply if build != host, or we are generating coverage data
1734 if test x$build != x$host || test "x$coverage_flags" != x
1735 then
1736     BUILD_CFLAGS='$(INTERNAL_CFLAGS) $(T_CFLAGS) $(CFLAGS_FOR_BUILD)'
1737     BUILD_LDFLAGS='$(LDFLAGS_FOR_BUILD)'
1738 fi
1739
1740 # Expand extra_headers to include complete path.
1741 # This substitutes for lots of t-* files.
1742 extra_headers_list=
1743 # Prepend $(srcdir)/config/${cpu_type}/ to every entry in extra_headers.
1744 for file in ${extra_headers} ; do
1745   extra_headers_list="${extra_headers_list} \$(srcdir)/config/${cpu_type}/${file}"
1746 done
1747
1748 # If use_gcc_tgmath is set, append ginclude/tgmath.h.
1749 if test x"$use_gcc_tgmath" = xyes
1750 then extra_headers_list="${extra_headers_list} \$(srcdir)/ginclude/tgmath.h"
1751 fi
1752
1753 # Define collect2 in Makefile.
1754 case $host_can_use_collect2 in
1755   no) collect2= ;;
1756   *) collect2='collect2$(exeext)' ;;
1757 esac
1758 AC_SUBST([collect2])
1759
1760 # Add a definition of USE_COLLECT2 if system wants one.
1761 case $use_collect2 in
1762   no) use_collect2= ;;
1763   "") ;;
1764   *) 
1765     host_xm_defines="${host_xm_defines} USE_COLLECT2"
1766     xm_defines="${xm_defines} USE_COLLECT2"
1767     case $host_can_use_collect2 in
1768       no)
1769         AC_MSG_ERROR([collect2 is required but cannot be built on this system])
1770         ;;
1771     esac
1772     ;;
1773 esac
1774
1775 # ---------------------------
1776 # Assembler & linker features
1777 # ---------------------------
1778
1779 # During stage 2, ld is actually gcc/collect-ld, which is a small script to
1780 # discern between when to use prev-ld/ld-new and when to use ld/ld-new.
1781 # However when ld-new is first executed from the build tree, libtool will
1782 # relink it as .libs/lt-ld-new, so that it can give it an RPATH that refers
1783 # to the build tree.  While doing this we need to use the previous-stage
1784 # linker, or we have an infinite loop.  The presence of a shell script as
1785 # ld/ld-new, and the fact that the script *uses ld itself*, is what confuses
1786 # the gcc/collect-ld script.  So we need to know how libtool works, or
1787 # exec-tool will fail.
1788
1789 m4_defun([_LT_CONFIG_COMMANDS], [])
1790 AC_PROG_LIBTOOL
1791 AC_SUBST(objdir)
1792 AC_SUBST(enable_fast_install)
1793
1794 # Identify the assembler which will work hand-in-glove with the newly
1795 # built GCC, so that we can examine its features.  This is the assembler
1796 # which will be driven by the driver program.
1797 #
1798 # If build != host, and we aren't building gas in-tree, we identify a
1799 # build->target assembler and hope that it will have the same features
1800 # as the host->target assembler we'll be using.
1801 gcc_cv_gas_major_version=
1802 gcc_cv_gas_minor_version=
1803 gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
1804
1805 m4_pattern_allow([AS_FOR_TARGET])dnl
1806 AS_VAR_SET_IF(gcc_cv_as,, [
1807 if test -x "$DEFAULT_ASSEMBLER"; then
1808         gcc_cv_as="$DEFAULT_ASSEMBLER"
1809 elif test -f $gcc_cv_as_gas_srcdir/configure.in \
1810      && test -f ../gas/Makefile \
1811      && test x$build = x$host; then
1812         gcc_cv_as=../gas/as-new$build_exeext
1813 elif test -x as$build_exeext; then
1814         # Build using assembler in the current directory.
1815         gcc_cv_as=./as$build_exeext
1816 elif test -x $AS_FOR_TARGET; then
1817         gcc_cv_as="$AS_FOR_TARGET"
1818 else
1819         AC_PATH_PROG(gcc_cv_as, $AS_FOR_TARGET)
1820 fi])
1821
1822 ORIGINAL_AS_FOR_TARGET=$gcc_cv_as
1823 AC_SUBST(ORIGINAL_AS_FOR_TARGET)
1824 case "$ORIGINAL_AS_FOR_TARGET" in
1825   ./as | ./as$build_exeext) ;;
1826   *) AC_CONFIG_FILES(as:exec-tool.in, [chmod +x as]) ;;
1827 esac 
1828
1829 AC_MSG_CHECKING(what assembler to use)
1830 if test "$gcc_cv_as" = ../gas/as-new$build_exeext; then
1831   # Single tree build which includes gas.  We want to prefer it
1832   # over whatever linker top-level may have detected, since
1833   # we'll use what we're building after installation anyway.
1834   AC_MSG_RESULT(newly built gas)
1835   in_tree_gas=yes
1836   _gcc_COMPUTE_GAS_VERSION
1837   in_tree_gas_is_elf=no
1838   if grep 'obj_format = elf' ../gas/Makefile > /dev/null \
1839      || (grep 'obj_format = multi' ../gas/Makefile \
1840          && grep 'extra_objects =.* obj-elf' ../gas/Makefile) > /dev/null
1841   then
1842     in_tree_gas_is_elf=yes
1843   fi
1844 else
1845   AC_MSG_RESULT($gcc_cv_as)
1846   in_tree_gas=no
1847 fi
1848
1849 # Identify the linker which will work hand-in-glove with the newly
1850 # built GCC, so that we can examine its features.  This is the linker
1851 # which will be driven by the driver program.
1852 #
1853 # If build != host, and we aren't building gas in-tree, we identify a
1854 # build->target linker and hope that it will have the same features
1855 # as the host->target linker we'll be using.
1856 gcc_cv_gld_major_version=
1857 gcc_cv_gld_minor_version=
1858 gcc_cv_ld_gld_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/ld
1859 gcc_cv_ld_bfd_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/bfd
1860
1861 AS_VAR_SET_IF(gcc_cv_ld,, [
1862 if test -x "$DEFAULT_LINKER"; then
1863         gcc_cv_ld="$DEFAULT_LINKER"
1864 elif test -f $gcc_cv_ld_gld_srcdir/configure.in \
1865      && test -f ../ld/Makefile \
1866      && test x$build = x$host; then
1867         gcc_cv_ld=../ld/ld-new$build_exeext
1868 elif test -x collect-ld$build_exeext; then
1869         # Build using linker in the current directory.
1870         gcc_cv_ld=./collect-ld$build_exeext
1871 elif test -x $LD_FOR_TARGET; then
1872         gcc_cv_ld="$LD_FOR_TARGET"
1873 else
1874         AC_PATH_PROG(gcc_cv_ld, $LD_FOR_TARGET)
1875 fi])
1876
1877 ORIGINAL_LD_FOR_TARGET=$gcc_cv_ld
1878 AC_SUBST(ORIGINAL_LD_FOR_TARGET)
1879 case "$ORIGINAL_LD_FOR_TARGET" in
1880   ./collect-ld | ./collect-ld$build_exeext) ;;
1881   *) AC_CONFIG_FILES(collect-ld:exec-tool.in, [chmod +x collect-ld]) ;;
1882 esac 
1883
1884 AC_MSG_CHECKING(what linker to use)
1885 if test "$gcc_cv_ld" = ../ld/ld-new$build_exeext; then
1886         # Single tree build which includes ld.  We want to prefer it
1887         # over whatever linker top-level may have detected, since
1888         # we'll use what we're building after installation anyway.
1889         AC_MSG_RESULT(newly built ld)
1890         in_tree_ld=yes
1891         in_tree_ld_is_elf=no
1892         if (grep 'EMUL = .*elf' ../ld/Makefile \
1893             || grep 'EMUL = .*linux' ../ld/Makefile \
1894             || grep 'EMUL = .*lynx' ../ld/Makefile) > /dev/null; then
1895           in_tree_ld_is_elf=yes
1896         fi
1897         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
1898         do
1899 changequote(,)dnl
1900                 gcc_cv_gld_version=`sed -n -e 's/^[     ]*\(VERSION=[0-9]*\.[0-9]*.*\)/\1/p' < $f`
1901                 if test x$gcc_cv_gld_version != x; then
1902                         break
1903                 fi
1904         done
1905         gcc_cv_gld_major_version=`expr "$gcc_cv_gld_version" : "VERSION=\([0-9]*\)"`
1906         gcc_cv_gld_minor_version=`expr "$gcc_cv_gld_version" : "VERSION=[0-9]*\.\([0-9]*\)"`
1907 changequote([,])dnl
1908 else
1909         AC_MSG_RESULT($gcc_cv_ld)
1910         in_tree_ld=no
1911 fi
1912
1913 # Figure out what nm we will be using.
1914 gcc_cv_binutils_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/binutils
1915 AS_VAR_SET_IF(gcc_cv_nm,, [
1916 if test -f $gcc_cv_binutils_srcdir/configure.in \
1917      && test -f ../binutils/Makefile \
1918      && test x$build = x$host; then
1919         gcc_cv_nm=../binutils/nm-new$build_exeext
1920 elif test -x nm$build_exeext; then
1921         gcc_cv_nm=./nm$build_exeext
1922 elif test -x $NM_FOR_TARGET; then
1923         gcc_cv_nm="$NM_FOR_TARGET"
1924 else
1925         AC_PATH_PROG(gcc_cv_nm, $NM_FOR_TARGET)
1926 fi])
1927
1928 AC_MSG_CHECKING(what nm to use)
1929 if test "$gcc_cv_nm" = ../binutils/nm-new$build_exeext; then
1930         # Single tree build which includes binutils.
1931         AC_MSG_RESULT(newly built nm)
1932         in_tree_nm=yes
1933 else
1934         AC_MSG_RESULT($gcc_cv_nm)
1935         in_tree_nm=no
1936 fi
1937
1938 ORIGINAL_NM_FOR_TARGET=$gcc_cv_nm
1939 AC_SUBST(ORIGINAL_NM_FOR_TARGET)
1940 case "$ORIGINAL_NM_FOR_TARGET" in
1941   ./nm | ./nm$build_exeext) ;;
1942   *) AC_CONFIG_FILES(nm:exec-tool.in, [chmod +x nm]) ;;
1943 esac
1944
1945
1946 # Figure out what objdump we will be using.
1947 AS_VAR_SET_IF(gcc_cv_objdump,, [
1948 if test -f $gcc_cv_binutils_srcdir/configure.in \
1949      && test -f ../binutils/Makefile \
1950      && test x$build = x$host; then
1951         # Single tree build which includes binutils.
1952         gcc_cv_objdump=../binutils/objdump$build_exeext
1953 elif test -x objdump$build_exeext; then
1954         gcc_cv_objdump=./objdump$build_exeext
1955 elif test -x $OBJDUMP_FOR_TARGET; then
1956         gcc_cv_objdump="$OBJDUMP_FOR_TARGET"
1957 else
1958         AC_PATH_PROG(gcc_cv_objdump, $OBJDUMP_FOR_TARGET)
1959 fi])
1960
1961 AC_MSG_CHECKING(what objdump to use)
1962 if test "$gcc_cv_objdump" = ../binutils/objdump$build_exeext; then
1963         # Single tree build which includes binutils.
1964         AC_MSG_RESULT(newly built objdump)
1965 elif test x$gcc_cv_objdump = x; then
1966         AC_MSG_RESULT(not found)
1967 else
1968         AC_MSG_RESULT($gcc_cv_objdump)
1969 fi
1970
1971 # Figure out what readelf we will be using.
1972 AS_VAR_SET_IF(gcc_cv_readelf,, [
1973 if test -f $gcc_cv_binutils_srcdir/configure.in \
1974      && test -f ../binutils/Makefile \
1975      && test x$build = x$host; then
1976         # Single tree build which includes binutils.
1977         gcc_cv_readelf=../binutils/readelf$build_exeext
1978 elif test -x readelf$build_exeext; then
1979         gcc_cv_readelf=./readelf$build_exeext
1980 else
1981         AC_PATH_PROG(gcc_cv_readelf, readelf)
1982 fi])
1983
1984 AC_MSG_CHECKING(what readelf to use)
1985 if test "$gcc_cv_readelf" = ../binutils/readelf$build_exeext; then
1986         # Single tree build which includes binutils.
1987         AC_MSG_RESULT(newly built readelf)
1988 elif test x$gcc_cv_readelf = x; then
1989         AC_MSG_RESULT(not found)
1990 else
1991         AC_MSG_RESULT($gcc_cv_readelf)
1992 fi
1993
1994 # Figure out what assembler alignment features are present.
1995 gcc_GAS_CHECK_FEATURE([.balign and .p2align], gcc_cv_as_balign_and_p2align,
1996  [2,6,0],,
1997 [.balign 4
1998 .p2align 2],,
1999 [AC_DEFINE(HAVE_GAS_BALIGN_AND_P2ALIGN, 1,
2000   [Define if your assembler supports .balign and .p2align.])])
2001
2002 gcc_GAS_CHECK_FEATURE([.p2align with maximum skip], gcc_cv_as_max_skip_p2align,
2003  [2,8,0],,
2004  [.p2align 4,,7],,
2005 [AC_DEFINE(HAVE_GAS_MAX_SKIP_P2ALIGN, 1,
2006   [Define if your assembler supports specifying the maximum number
2007    of bytes to skip when using the GAS .p2align command.])])
2008
2009 gcc_GAS_CHECK_FEATURE([.literal16], gcc_cv_as_literal16,
2010  [2,8,0],,
2011  [.literal16],,
2012 [AC_DEFINE(HAVE_GAS_LITERAL16, 1,
2013   [Define if your assembler supports .literal16.])])
2014
2015 gcc_GAS_CHECK_FEATURE([working .subsection -1], gcc_cv_as_subsection_m1,
2016  [elf,2,9,0],,
2017  [conftest_label1: .word 0
2018 .subsection -1
2019 conftest_label2: .word 0
2020 .previous],
2021  [if test x$gcc_cv_nm != x; then
2022     $gcc_cv_nm conftest.o | grep conftest_label1 > conftest.nm1
2023     $gcc_cv_nm conftest.o | grep conftest_label2 | sed -e 's/label2/label1/' > conftest.nm2
2024     if cmp conftest.nm1 conftest.nm2 > /dev/null 2>&1
2025     then :
2026     else gcc_cv_as_subsection_m1=yes
2027     fi
2028     rm -f conftest.nm1 conftest.nm2
2029   fi],
2030  [AC_DEFINE(HAVE_GAS_SUBSECTION_ORDERING, 1,
2031   [Define if your assembler supports .subsection and .subsection -1 starts
2032    emitting at the beginning of your section.])])
2033
2034 gcc_GAS_CHECK_FEATURE([.weak], gcc_cv_as_weak,
2035  [2,2,0],,
2036  [      .weak foobar],,
2037 [AC_DEFINE(HAVE_GAS_WEAK, 1, [Define if your assembler supports .weak.])])
2038
2039 gcc_GAS_CHECK_FEATURE([.weakref], gcc_cv_as_weakref,
2040  [2,17,0],,
2041  [      .weakref foobar, barfnot],,
2042 [AC_DEFINE(HAVE_GAS_WEAKREF, 1, [Define if your assembler supports .weakref.])])
2043
2044 gcc_GAS_CHECK_FEATURE([.nsubspa comdat], gcc_cv_as_nsubspa_comdat,
2045  [2,15,91],,
2046  [      .SPACE $TEXT$
2047         .NSUBSPA $CODE$,COMDAT],,
2048 [AC_DEFINE(HAVE_GAS_NSUBSPA_COMDAT, 1, [Define if your assembler supports .nsubspa comdat option.])])
2049
2050 # .hidden needs to be supported in both the assembler and the linker,
2051 # because GNU LD versions before 2.12.1 have buggy support for STV_HIDDEN.
2052 # This is irritatingly difficult to feature test for; we have to check the
2053 # date string after the version number.  If we've got an in-tree
2054 # ld, we don't know its patchlevel version, so we set the baseline at 2.13
2055 # to be safe.
2056 # The gcc_GAS_CHECK_FEATURE call just sets a cache variable.
2057 gcc_GAS_CHECK_FEATURE([.hidden], gcc_cv_as_hidden,
2058  [elf,2,13,0],,
2059 [       .hidden foobar
2060 foobar:])
2061
2062 AC_CACHE_CHECK(linker for .hidden support, gcc_cv_ld_hidden,
2063 [if test $in_tree_ld = yes ; then
2064   gcc_cv_ld_hidden=no
2065   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 \
2066      && test $in_tree_ld_is_elf = yes; then
2067      gcc_cv_ld_hidden=yes
2068   fi
2069 else
2070 changequote(,)dnl
2071   gcc_cv_ld_hidden=yes
2072   ld_ver=`$gcc_cv_ld --version 2>/dev/null | sed 1q`
2073   if echo "$ld_ver" | grep GNU > /dev/null; then
2074     ld_vers=`echo $ld_ver | sed -n \
2075         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2076     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'`
2077     ld_vers_major=`expr "$ld_vers" : '\([0-9]*\)'`
2078     ld_vers_minor=`expr "$ld_vers" : '[0-9]*\.\([0-9]*\)'`
2079     ld_vers_patch=`expr "$ld_vers" : '[0-9]*\.[0-9]*\.\([0-9]*\)'`
2080     if test 0"$ld_date" -lt 20020404; then
2081       if test -n "$ld_date"; then
2082         # If there was date string, but was earlier than 2002-04-04, fail
2083         gcc_cv_ld_hidden=no
2084       elif test -z "$ld_vers"; then
2085         # If there was no date string nor ld version number, something is wrong
2086         gcc_cv_ld_hidden=no
2087       else
2088         test -z "$ld_vers_patch" && ld_vers_patch=0
2089         if test "$ld_vers_major" -lt 2; then
2090           gcc_cv_ld_hidden=no
2091         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 12; then
2092           gcc_cv_ld_hidden="no"
2093         elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -eq 12 -a "$ld_vers_patch" -eq 0; then
2094           gcc_cv_ld_hidden=no
2095         fi
2096       fi
2097     fi
2098   else
2099     case "${target}" in
2100       hppa64*-*-hpux* | ia64*-*-hpux*)
2101         gcc_cv_ld_hidden=yes
2102         ;;
2103       *-*-solaris2.9* | *-*-solaris2.1[0-9]*)
2104         gcc_cv_ld_hidden=yes
2105         ;;
2106       *)
2107         gcc_cv_ld_hidden=no
2108         ;;
2109     esac
2110   fi
2111 changequote([,])dnl
2112 fi])
2113 libgcc_visibility=no
2114 AC_SUBST(libgcc_visibility)
2115 GCC_TARGET_TEMPLATE([HAVE_GAS_HIDDEN])
2116 if test $gcc_cv_as_hidden = yes && test $gcc_cv_ld_hidden = yes; then
2117   libgcc_visibility=yes
2118   AC_DEFINE(HAVE_GAS_HIDDEN, 1,
2119   [Define if your assembler and linker support .hidden.])
2120 fi
2121
2122 AC_MSG_CHECKING(linker read-only and read-write section mixing)
2123 gcc_cv_ld_ro_rw_mix=unknown
2124 if test $in_tree_ld = yes ; then
2125   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 \
2126      && test $in_tree_ld_is_elf = yes; then
2127     gcc_cv_ld_ro_rw_mix=read-write
2128   fi
2129 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
2130   echo '.section myfoosect, "a"' > conftest1.s
2131   echo '.section myfoosect, "aw"' > conftest2.s
2132   echo '.byte 1' >> conftest2.s
2133   echo '.section myfoosect, "a"' > conftest3.s
2134   echo '.byte 0' >> conftest3.s
2135   if $gcc_cv_as -o conftest1.o conftest1.s > /dev/null 2>&1 \
2136      && $gcc_cv_as -o conftest2.o conftest2.s > /dev/null 2>&1 \
2137      && $gcc_cv_as -o conftest3.o conftest3.s > /dev/null 2>&1 \
2138      && $gcc_cv_ld -shared -o conftest1.so conftest1.o \
2139         conftest2.o conftest3.o > /dev/null 2>&1; then
2140     gcc_cv_ld_ro_rw_mix=`$gcc_cv_objdump -h conftest1.so \
2141                          | sed -e '/myfoosect/!d' -e N`
2142     if echo "$gcc_cv_ld_ro_rw_mix" | grep CONTENTS > /dev/null; then
2143       if echo "$gcc_cv_ld_ro_rw_mix" | grep READONLY > /dev/null; then
2144         gcc_cv_ld_ro_rw_mix=read-only
2145       else
2146         gcc_cv_ld_ro_rw_mix=read-write
2147       fi
2148     fi
2149   fi
2150 changequote(,)dnl
2151   rm -f conftest.* conftest[123].*
2152 changequote([,])dnl
2153 fi
2154 if test x$gcc_cv_ld_ro_rw_mix = xread-write; then
2155         AC_DEFINE(HAVE_LD_RO_RW_SECTION_MIXING, 1,
2156   [Define if your linker links a mix of read-only
2157    and read-write sections into a read-write section.])
2158 fi
2159 AC_MSG_RESULT($gcc_cv_ld_ro_rw_mix)
2160
2161 # Check if we have .[us]leb128, and support symbol arithmetic with it.
2162 gcc_GAS_CHECK_FEATURE([.sleb128 and .uleb128], gcc_cv_as_leb128,
2163   [elf,2,11,0],,
2164 [       .data
2165         .uleb128 L2 - L1
2166 L1:
2167         .uleb128 1280
2168         .sleb128 -1010
2169 L2:],
2170  [# GAS versions before 2.11 do not support uleb128,
2171   # despite appearing to.
2172   # ??? There exists an elf-specific test that will crash
2173   # the assembler.  Perhaps it's better to figure out whether
2174   # arbitrary sections are supported and try the test.
2175   as_ver=`$gcc_cv_as --version 2>/dev/null | sed 1q`
2176   if echo "$as_ver" | grep GNU > /dev/null; then
2177 changequote(,)dnl
2178     as_vers=`echo $as_ver | sed -n \
2179         -e 's,^.*[       ]\([0-9][0-9]*\.[0-9][0-9]*.*\)$,\1,p'`
2180     as_major=`expr "$as_vers" : '\([0-9]*\)'`
2181     as_minor=`expr "$as_vers" : '[0-9]*\.\([0-9]*\)'`
2182 changequote([,])dnl
2183     if test $as_major -eq 2 && test $as_minor -lt 11
2184     then :
2185     else gcc_cv_as_leb128=yes
2186     fi
2187   fi],
2188   [AC_DEFINE(HAVE_AS_LEB128, 1,
2189     [Define if your assembler supports .sleb128 and .uleb128.])])
2190
2191 # Check if we have assembler support for unwind directives.
2192 gcc_GAS_CHECK_FEATURE([cfi directives], gcc_cv_as_cfi_directive,
2193   ,,
2194 [       .text
2195         .cfi_startproc
2196         .cfi_offset 0, 0
2197         .cfi_same_value 1
2198         .cfi_def_cfa 1, 2
2199         .cfi_escape 1, 2, 3, 4, 5
2200         .cfi_endproc],
2201 [case "$target" in
2202   *-*-solaris*)
2203     # If the linker used on Solaris (like Sun ld) isn't capable of merging
2204     # read-only and read-write sections, we need to make sure that the
2205     # assembler used emits read-write .eh_frame sections.
2206     if test "x$gcc_cv_ld_ro_rw_mix" != xread-write; then
2207       if test "x$gcc_cv_objdump" != x; then
2208         if $gcc_cv_objdump -h conftest.o 2>/dev/null | \
2209                 sed -e /.eh_frame/!d -e N | grep READONLY > /dev/null; then
2210           gcc_cv_as_cfi_directive=no
2211         else
2212           gcc_cv_as_cfi_directive=yes
2213         fi
2214       else
2215         # no objdump, err on the side of caution
2216         gcc_cv_as_cfi_directive=no
2217       fi
2218     else
2219       gcc_cv_as_cfi_directive=yes
2220     fi
2221     ;;
2222   *-*-*)
2223     gcc_cv_as_cfi_directive=yes
2224     ;;
2225 esac])
2226 if test $gcc_cv_as_cfi_directive = yes && test x$gcc_cv_readelf != x; then
2227 gcc_GAS_CHECK_FEATURE([working cfi advance], gcc_cv_as_cfi_advance_working,
2228   ,,
2229 [       .text
2230         .cfi_startproc
2231         .cfi_adjust_cfa_offset 64
2232         .skip 512, 0
2233         .cfi_adjust_cfa_offset 128
2234         .cfi_endproc],
2235 [
2236 changequote(,)dnl
2237 if $gcc_cv_readelf -wf conftest.o 2>/dev/null \
2238     | grep 'DW_CFA_advance_loc[12]:[    ][      ]*512[  ]' >/dev/null; then
2239    gcc_cv_as_cfi_advance_working=yes
2240 fi
2241 changequote([,])dnl
2242 ])
2243 else
2244   # no readelf, err on the side of caution
2245   gcc_cv_as_cfi_advance_working=no
2246 fi
2247 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_DIRECTIVE,
2248   [`if test $gcc_cv_as_cfi_directive = yes \
2249        && test $gcc_cv_as_cfi_advance_working = yes; then echo 1; else echo 0; fi`],
2250   [Define 0/1 if your assembler supports CFI directives.])
2251
2252 gcc_GAS_CHECK_FEATURE([cfi personality directive],
2253   gcc_cv_as_cfi_personality_directive, ,,
2254 [       .text
2255         .cfi_startproc
2256         .cfi_personality 0, symbol
2257         .cfi_endproc])
2258 AC_DEFINE_UNQUOTED(HAVE_GAS_CFI_PERSONALITY_DIRECTIVE,
2259   [`if test $gcc_cv_as_cfi_personality_directive = yes;
2260     then echo 1; else echo 0; fi`],
2261   [Define 0/1 if your assembler supports .cfi_personality.])
2262
2263 # GAS versions up to and including 2.11.0 may mis-optimize
2264 # .eh_frame data.
2265 gcc_GAS_CHECK_FEATURE(eh_frame optimization, gcc_cv_as_eh_frame,
2266   [elf,2,12,0],,
2267 [       .text
2268 .LFB1:
2269         .4byte  0
2270 .L1:
2271         .4byte  0
2272 .LFE1:
2273         .section        .eh_frame,"aw",@progbits
2274 __FRAME_BEGIN__:
2275         .4byte  .LECIE1-.LSCIE1
2276 .LSCIE1:
2277         .4byte  0x0
2278         .byte   0x1
2279         .ascii "z\0"
2280         .byte   0x1
2281         .byte   0x78
2282         .byte   0x1a
2283         .byte   0x0
2284         .byte   0x4
2285         .4byte  1
2286         .p2align 1
2287 .LECIE1:
2288 .LSFDE1:
2289         .4byte  .LEFDE1-.LASFDE1
2290 .LASFDE1:
2291         .4byte  .LASFDE1-__FRAME_BEGIN__
2292         .4byte  .LFB1
2293         .4byte  .LFE1-.LFB1
2294         .byte   0x4
2295         .4byte  .LFE1-.LFB1
2296         .byte   0x4
2297         .4byte  .L1-.LFB1
2298 .LEFDE1:],
2299 [  dnl # For autoconf 2.5x, must protect trailing spaces with @&t@.
2300 cat > conftest.lit <<EOF
2301  0000 10000000 00000000 017a0001 781a0004  .........z..x...
2302  0010 01000000 12000000 18000000 00000000  ................
2303  0020 08000000 04080000 0044               .........D      @&t@
2304 EOF
2305 cat > conftest.big <<EOF
2306  0000 00000010 00000000 017a0001 781a0004  .........z..x...
2307  0010 00000001 00000012 00000018 00000000  ................
2308  0020 00000008 04000000 0844               .........D      @&t@
2309 EOF
2310   # If the assembler didn't choke, and we can objdump,
2311   # and we got the correct data, then succeed.
2312   # The text in the here-document typically retains its unix-style line
2313   # endings, while the output of objdump will use host line endings.
2314   # Therefore, use diff -b for the comparisons.
2315   if test x$gcc_cv_objdump != x \
2316   && $gcc_cv_objdump -s -j .eh_frame conftest.o 2>/dev/null \
2317      | tail -3 > conftest.got \
2318   && { diff -b conftest.lit conftest.got > /dev/null 2>&1 \
2319     || diff -b conftest.big conftest.got > /dev/null 2>&1; }
2320   then
2321     gcc_cv_as_eh_frame=yes
2322   elif AC_TRY_COMMAND($gcc_cv_as -o conftest.o --traditional-format /dev/null); then
2323     gcc_cv_as_eh_frame=buggy
2324   else
2325     # Uh oh, what do we do now?
2326     gcc_cv_as_eh_frame=no
2327   fi])
2328
2329 if test $gcc_cv_as_eh_frame = buggy; then
2330   AC_DEFINE(USE_AS_TRADITIONAL_FORMAT, 1,
2331   [Define if your assembler mis-optimizes .eh_frame data.])
2332 fi
2333
2334 gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2335  [elf,2,12,0], [--fatal-warnings],
2336  [.section .rodata.str, "aMS", @progbits, 1])
2337 if test $gcc_cv_as_shf_merge = no; then
2338   gcc_GAS_CHECK_FEATURE(section merging support, gcc_cv_as_shf_merge,
2339     [elf,2,12,0], [--fatal-warnings],
2340     [.section .rodata.str, "aMS", %progbits, 1])
2341 fi
2342 AC_DEFINE_UNQUOTED(HAVE_GAS_SHF_MERGE,
2343   [`if test $gcc_cv_as_shf_merge = yes; then echo 1; else echo 0; fi`],
2344 [Define 0/1 if your assembler supports marking sections with SHF_MERGE flag.])
2345
2346 gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group,
2347  [elf,2,16,0], [--fatal-warnings],
2348  [.section .text,"axG",@progbits,.foo,comdat])
2349 if test $gcc_cv_as_comdat_group = yes; then
2350   gcc_cv_as_comdat_group_percent=no
2351 else
2352  gcc_GAS_CHECK_FEATURE(COMDAT group support, gcc_cv_as_comdat_group_percent,
2353    [elf,2,16,0], [--fatal-warnings],
2354    [.section .text,"axG",%progbits,.foo,comdat])
2355 fi
2356 if test $in_tree_ld != yes && test x"$ld_vers" != x; then
2357   comdat_group=yes
2358   if test 0"$ld_date" -lt 20050308; then
2359     if test -n "$ld_date"; then
2360       # If there was date string, but was earlier than 2005-03-08, fail
2361       comdat_group=no
2362     elif test "$ld_vers_major" -lt 2; then
2363       comdat_group=no
2364     elif test "$ld_vers_major" -eq 2 -a "$ld_vers_minor" -lt 16; then
2365       comdat_group=no
2366     fi
2367   fi
2368 else
2369   # assume linkers other than GNU ld don't support COMDAT group
2370   comdat_group=no
2371 fi
2372 if test $comdat_group = no; then
2373   gcc_cv_as_comdat_group=no
2374   gcc_cv_as_comdat_group_percent=no
2375 fi
2376 AC_DEFINE_UNQUOTED(HAVE_COMDAT_GROUP,
2377   [`if test $gcc_cv_as_comdat_group = yes || test $gcc_cv_as_comdat_group_percent = yes; then echo 1; else echo 0; fi`],
2378 [Define 0/1 if your assembler and linker support COMDAT groups.])
2379
2380 # Thread-local storage - the check is heavily parameterized.
2381 conftest_s=
2382 tls_first_major=
2383 tls_first_minor=
2384 tls_as_opt=
2385 case "$target" in
2386 changequote(,)dnl
2387   alpha*-*-*)
2388     conftest_s='
2389         .section ".tdata","awT",@progbits
2390 foo:    .long   25
2391         .text
2392         ldq     $27,__tls_get_addr($29)         !literal!1
2393         lda     $16,foo($29)                    !tlsgd!1
2394         jsr     $26,($27),__tls_get_addr        !lituse_tlsgd!1
2395         ldq     $27,__tls_get_addr($29)         !literal!2
2396         lda     $16,foo($29)                    !tlsldm!2
2397         jsr     $26,($27),__tls_get_addr        !lituse_tlsldm!2
2398         ldq     $1,foo($29)                     !gotdtprel
2399         ldah    $2,foo($29)                     !dtprelhi
2400         lda     $3,foo($2)                      !dtprello
2401         lda     $4,foo($29)                     !dtprel
2402         ldq     $1,foo($29)                     !gottprel
2403         ldah    $2,foo($29)                     !tprelhi
2404         lda     $3,foo($2)                      !tprello
2405         lda     $4,foo($29)                     !tprel'
2406         tls_first_major=2
2407         tls_first_minor=13
2408         tls_as_opt=--fatal-warnings
2409         ;;
2410   cris-*-*|crisv32-*-*)
2411     conftest_s='
2412         .section ".tdata","awT",@progbits
2413 x:      .long   25
2414         .text
2415         move.d x:IE,$r10
2416         nop'
2417         tls_first_major=2
2418         tls_first_minor=20
2419         tls_as_opt=--fatal-warnings
2420         ;;
2421   frv*-*-*)
2422     conftest_s='
2423         .section ".tdata","awT",@progbits
2424 x:      .long   25
2425         .text
2426         call    #gettlsoff(x)'
2427         tls_first_major=2
2428         tls_first_minor=14
2429         ;;
2430   hppa*-*-linux*)
2431     conftest_s='
2432 t1:     .reg    %r20
2433 t2:     .reg    %r21
2434 gp:     .reg    %r19
2435         .section ".tdata","awT",@progbits
2436 foo:    .long   25
2437         .text
2438         .align  4
2439         addil LT%foo-$tls_gdidx$,gp
2440         ldo RT%foo-$tls_gdidx$(%r1),%arg0
2441         b __tls_get_addr
2442         nop             
2443         addil LT%foo-$tls_ldidx$,gp
2444         b __tls_get_addr
2445         ldo RT%foo-$tls_ldidx$(%r1),%arg0
2446         addil LR%foo-$tls_dtpoff$,%ret0
2447         ldo RR%foo-$tls_dtpoff$(%r1),%t1
2448         mfctl %cr27,%t1                 
2449         addil LT%foo-$tls_ieoff$,gp
2450         ldw RT%foo-$tls_ieoff$(%r1),%t2
2451         add %t1,%t2,%t3                 
2452         mfctl %cr27,%t1                 
2453         addil LR%foo-$tls_leoff$,%t1
2454         ldo RR%foo-$tls_leoff$(%r1),%t2'
2455         tls_first_major=2
2456         tls_first_minor=15
2457         tls_as_opt=--fatal-warnings
2458         ;;
2459   arm*-*-*)
2460     conftest_s='
2461         .section ".tdata","awT",%progbits
2462 foo:    .long   25
2463         .text
2464 .word foo(gottpoff)
2465 .word foo(tpoff)
2466 .word foo(tlsgd)
2467 .word foo(tlsldm)
2468 .word foo(tlsldo)'
2469         tls_first_major=2
2470         tls_first_minor=17
2471         ;;
2472   i[34567]86-*-*)
2473     conftest_s='
2474         .section ".tdata","awT",@progbits
2475 foo:    .long   25
2476         .text
2477         movl    %gs:0, %eax
2478         leal    foo@TLSGD(,%ebx,1), %eax
2479         leal    foo@TLSLDM(%ebx), %eax
2480         leal    foo@DTPOFF(%eax), %edx
2481         movl    foo@GOTTPOFF(%ebx), %eax
2482         subl    foo@GOTTPOFF(%ebx), %eax
2483         addl    foo@GOTNTPOFF(%ebx), %eax
2484         movl    foo@INDNTPOFF, %eax
2485         movl    $foo@TPOFF, %eax
2486         subl    $foo@TPOFF, %eax
2487         leal    foo@NTPOFF(%ecx), %eax'
2488         tls_first_major=2
2489         tls_first_minor=14
2490         tls_as_opt=--fatal-warnings
2491         ;;
2492   x86_64-*-*)
2493     conftest_s='
2494         .section ".tdata","awT",@progbits
2495 foo:    .long   25
2496         .text
2497         movq    %fs:0, %rax
2498         leaq    foo@TLSGD(%rip), %rdi
2499         leaq    foo@TLSLD(%rip), %rdi
2500         leaq    foo@DTPOFF(%rax), %rdx
2501         movq    foo@GOTTPOFF(%rip), %rax
2502         movq    $foo@TPOFF, %rax'
2503         tls_first_major=2
2504         tls_first_minor=14
2505         tls_as_opt=--fatal-warnings
2506         ;;
2507   ia64-*-*)
2508     conftest_s='
2509         .section ".tdata","awT",@progbits
2510 foo:    data8   25
2511         .text
2512         addl    r16 = @ltoff(@dtpmod(foo#)), gp
2513         addl    r17 = @ltoff(@dtprel(foo#)), gp
2514         addl    r18 = @ltoff(@tprel(foo#)), gp
2515         addl    r19 = @dtprel(foo#), gp
2516         adds    r21 = @dtprel(foo#), r13
2517         movl    r23 = @dtprel(foo#)
2518         addl    r20 = @tprel(foo#), gp
2519         adds    r22 = @tprel(foo#), r13
2520         movl    r24 = @tprel(foo#)'
2521         tls_first_major=2
2522         tls_first_minor=13
2523         tls_as_opt=--fatal-warnings
2524         ;;
2525   mips*-*-*)
2526     conftest_s='
2527         .section .tdata,"awT",@progbits
2528 x:
2529         .word 2
2530         .text
2531         addiu $4, $28, %tlsgd(x)
2532         addiu $4, $28, %tlsldm(x)
2533         lui $4, %dtprel_hi(x)
2534         addiu $4, $4, %dtprel_lo(x)
2535         lw $4, %gottprel(x)($28)
2536         lui $4, %tprel_hi(x)
2537         addiu $4, $4, %tprel_lo(x)'
2538         tls_first_major=2
2539         tls_first_minor=16
2540         tls_as_opt='-32 --fatal-warnings'
2541         ;;
2542   powerpc-*-*)
2543     conftest_s='
2544         .section ".tdata","awT",@progbits
2545         .align 2
2546 ld0:    .space 4
2547 ld1:    .space 4
2548 x1:     .space 4
2549 x2:     .space 4
2550 x3:     .space 4
2551         .text
2552         addi 3,31,ld0@got@tlsgd
2553         bl __tls_get_addr
2554         addi 3,31,x1@got@tlsld
2555         bl __tls_get_addr
2556         addi 9,3,x1@dtprel
2557         addis 9,3,x2@dtprel@ha
2558         addi 9,9,x2@dtprel@l
2559         lwz 9,x3@got@tprel(31)
2560         add 9,9,x@tls
2561         addi 9,2,x1@tprel
2562         addis 9,2,x2@tprel@ha
2563         addi 9,9,x2@tprel@l'
2564         tls_first_major=2
2565         tls_first_minor=14
2566         tls_as_opt="-a32 --fatal-warnings"
2567         ;;
2568   powerpc64-*-*)
2569     conftest_s='
2570         .section ".tdata","awT",@progbits
2571         .align 3
2572 ld0:    .space 8
2573 ld1:    .space 8
2574 x1:     .space 8
2575 x2:     .space 8
2576 x3:     .space 8
2577         .text
2578         addi 3,2,ld0@got@tlsgd
2579         bl .__tls_get_addr
2580         nop
2581         addi 3,2,ld1@toc
2582         bl .__tls_get_addr
2583         nop
2584         addi 3,2,x1@got@tlsld
2585         bl .__tls_get_addr
2586         nop
2587         addi 9,3,x1@dtprel
2588         bl .__tls_get_addr
2589         nop
2590         addis 9,3,x2@dtprel@ha
2591         addi 9,9,x2@dtprel@l
2592         bl .__tls_get_addr
2593         nop
2594         ld 9,x3@got@dtprel(2)
2595         add 9,9,3
2596         bl .__tls_get_addr
2597         nop'
2598         tls_first_major=2
2599         tls_first_minor=14
2600         tls_as_opt="-a64 --fatal-warnings"
2601         ;;
2602   s390-*-*)
2603     conftest_s='
2604         .section ".tdata","awT",@progbits
2605 foo:    .long   25
2606         .text
2607         .long   foo@TLSGD
2608         .long   foo@TLSLDM
2609         .long   foo@DTPOFF
2610         .long   foo@NTPOFF
2611         .long   foo@GOTNTPOFF
2612         .long   foo@INDNTPOFF
2613         l       %r1,foo@GOTNTPOFF(%r12)
2614         l       %r1,0(%r1):tls_load:foo
2615         bas     %r14,0(%r1,%r13):tls_gdcall:foo
2616         bas     %r14,0(%r1,%r13):tls_ldcall:foo'
2617         tls_first_major=2
2618         tls_first_minor=14
2619         tls_as_opt="-m31 --fatal-warnings"
2620         ;;
2621   s390x-*-*)
2622     conftest_s='
2623         .section ".tdata","awT",@progbits
2624 foo:    .long   25
2625         .text
2626         .quad   foo@TLSGD
2627         .quad   foo@TLSLDM
2628         .quad   foo@DTPOFF
2629         .quad   foo@NTPOFF
2630         .quad   foo@GOTNTPOFF
2631         lg      %r1,foo@GOTNTPOFF(%r12)
2632         larl    %r1,foo@INDNTPOFF
2633         brasl   %r14,__tls_get_offset@PLT:tls_gdcall:foo
2634         brasl   %r14,__tls_get_offset@PLT:tls_ldcall:foo'
2635         tls_first_major=2
2636         tls_first_minor=14
2637         tls_as_opt="-m64 -Aesame --fatal-warnings"
2638         ;;
2639   sh-*-* | sh[34]-*-*)
2640     conftest_s='
2641         .section ".tdata","awT",@progbits
2642 foo:    .long   25
2643         .text
2644         .long   foo@TLSGD
2645         .long   foo@TLSLDM
2646         .long   foo@DTPOFF
2647         .long   foo@GOTTPOFF
2648         .long   foo@TPOFF'
2649         tls_first_major=2
2650         tls_first_minor=13
2651         tls_as_opt=--fatal-warnings
2652         ;;
2653   sparc*-*-*)
2654     case "$target" in
2655       sparc*-sun-solaris2.[56789]*)
2656         # TLS was introduced in the Solaris 9 4/04 release but
2657         # we do not enable it by default on Solaris 9 either.
2658         if test "x$enable_tls" = xyes ; then
2659           on_solaris=yes
2660         else
2661           enable_tls=no;
2662         fi
2663         ;;
2664       sparc*-sun-solaris2.*)
2665         on_solaris=yes
2666         ;;
2667       *)
2668         on_solaris=no
2669         ;;
2670     esac
2671     if test x$on_solaris = xyes && test x$gas_flag = xno; then
2672       conftest_s='
2673         .section ".tdata",#alloc,#write,#tls
2674 foo:    .long   25
2675         .text
2676         sethi   %tgd_hi22(foo), %o0
2677         add     %o0, %tgd_lo10(foo), %o1
2678         add     %l7, %o1, %o0, %tgd_add(foo)
2679         call    __tls_get_addr, %tgd_call(foo)
2680         sethi   %tldm_hi22(foo), %l1
2681         add     %l1, %tldm_lo10(foo), %l2
2682         add     %l7, %l2, %o0, %tldm_add(foo)
2683         call    __tls_get_addr, %tldm_call(foo)
2684         sethi   %tldo_hix22(foo), %l3
2685         xor     %l3, %tldo_lox10(foo), %l4
2686         add     %o0, %l4, %l5, %tldo_add(foo)
2687         sethi   %tie_hi22(foo), %o3
2688         add     %o3, %tie_lo10(foo), %o3
2689         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2690         add     %g7, %o2, %o4, %tie_add(foo)
2691         sethi   %tle_hix22(foo), %l1
2692         xor     %l1, %tle_lox10(foo), %o5
2693         ld      [%g7 + %o5], %o1'
2694         tls_first_major=0
2695         tls_first_minor=0
2696     else
2697       conftest_s='
2698         .section ".tdata","awT",@progbits
2699 foo:    .long   25
2700         .text
2701         sethi   %tgd_hi22(foo), %o0
2702         add     %o0, %tgd_lo10(foo), %o1
2703         add     %l7, %o1, %o0, %tgd_add(foo)
2704         call    __tls_get_addr, %tgd_call(foo)
2705         sethi   %tldm_hi22(foo), %l1
2706         add     %l1, %tldm_lo10(foo), %l2
2707         add     %l7, %l2, %o0, %tldm_add(foo)
2708         call    __tls_get_addr, %tldm_call(foo)
2709         sethi   %tldo_hix22(foo), %l3
2710         xor     %l3, %tldo_lox10(foo), %l4
2711         add     %o0, %l4, %l5, %tldo_add(foo)
2712         sethi   %tie_hi22(foo), %o3
2713         add     %o3, %tie_lo10(foo), %o3
2714         ld      [%l7 + %o3], %o2, %tie_ld(foo)
2715         add     %g7, %o2, %o4, %tie_add(foo)
2716         sethi   %tle_hix22(foo), %l1
2717         xor     %l1, %tle_lox10(foo), %o5
2718         ld      [%g7 + %o5], %o1'
2719         tls_first_major=2
2720         tls_first_minor=14
2721         tls_as_opt="-32 --fatal-warnings"
2722       fi
2723         ;;
2724   xtensa*-*-*)
2725     conftest_s='
2726         .section ".tdata","awT",@progbits
2727 foo:    .long   25
2728         .text
2729         movi    a8, foo@TLSFUNC
2730         movi    a10, foo@TLSARG
2731         callx8.tls a8, foo@TLSCALL'
2732         tls_first_major=2
2733         tls_first_minor=19
2734         ;;
2735 changequote([,])dnl
2736 esac
2737 set_have_as_tls=no
2738 if test "x$enable_tls" = xno ; then
2739   : # TLS explicitly disabled.
2740 elif test "x$enable_tls" = xyes ; then
2741   set_have_as_tls=yes # TLS explicitly enabled.
2742 elif test -z "$tls_first_major"; then
2743   : # If we don't have a check, assume no support.
2744 else
2745   gcc_GAS_CHECK_FEATURE(thread-local storage support, gcc_cv_as_tls,
2746   [$tls_first_major,$tls_first_minor,0], [$tls_as_opt], [$conftest_s],,
2747   [set_have_as_tls=yes])
2748 fi
2749 if test $set_have_as_tls = yes ; then
2750   AC_DEFINE(HAVE_AS_TLS, 1,
2751             [Define if your assembler supports thread-local storage.])
2752 fi
2753
2754 # Target-specific assembler checks.
2755
2756 AC_MSG_CHECKING(linker -Bstatic/-Bdynamic option)
2757 gcc_cv_ld_static_dynamic=no
2758 if test $in_tree_ld = yes ; then
2759   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
2760     gcc_cv_ld_static_dynamic=yes
2761   fi
2762 elif test x$gcc_cv_ld != x; then
2763         # Check if linker supports -Bstatic/-Bdynamic option
2764         if $gcc_cv_ld --help 2>/dev/null | grep -- -Bstatic > /dev/null \
2765           && $gcc_cv_ld --help 2>/dev/null | grep -- -Bdynamic > /dev/null; then
2766                 gcc_cv_ld_static_dynamic=yes
2767         fi
2768 fi
2769 if test x"$gcc_cv_ld_static_dynamic" = xyes; then
2770         AC_DEFINE(HAVE_LD_STATIC_DYNAMIC, 1,
2771 [Define if your linker supports -Bstatic/-Bdynamic option.])
2772 fi
2773 AC_MSG_RESULT($gcc_cv_ld_static_dynamic)
2774
2775 if test x"$demangler_in_ld" = xyes; then
2776   AC_MSG_CHECKING(linker --demangle support)
2777   gcc_cv_ld_demangle=no
2778   if test $in_tree_ld = yes; then
2779     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 \
2780       gcc_cv_ld_demangle=yes
2781     fi
2782   elif test x$gcc_cv_ld != x -a x"$gnu_ld" = xyes; then
2783     # Check if the GNU linker supports --demangle option
2784     if $gcc_cv_ld --help 2>/dev/null | grep no-demangle > /dev/null; then
2785       gcc_cv_ld_demangle=yes
2786     fi
2787   fi
2788   if test x"$gcc_cv_ld_demangle" = xyes; then
2789     AC_DEFINE(HAVE_LD_DEMANGLE, 1,
2790 [Define if your linker supports --demangle option.])
2791   fi
2792   AC_MSG_RESULT($gcc_cv_ld_demangle)
2793 fi
2794
2795 case "$target" in
2796   # All TARGET_ABI_OSF targets.
2797   alpha*-*-osf* | alpha*-*-linux* | alpha*-*-*bsd*)
2798     gcc_GAS_CHECK_FEATURE([explicit relocation support],
2799         gcc_cv_as_alpha_explicit_relocs, [2,12,0],,
2800 [       .set nomacro
2801         .text
2802         extbl   $3, $2, $3      !lituse_bytoff!1
2803         ldq     $2, a($29)      !literal!1
2804         ldq     $4, b($29)      !literal!2
2805         ldq_u   $3, 0($2)       !lituse_base!1
2806         ldq     $27, f($29)     !literal!5
2807         jsr     $26, ($27), f   !lituse_jsr!5
2808         ldah    $29, 0($26)     !gpdisp!3
2809         lda     $0, c($29)      !gprel
2810         ldah    $1, d($29)      !gprelhigh
2811         lda     $1, d($1)       !gprellow
2812         lda     $29, 0($29)     !gpdisp!3],,
2813     [AC_DEFINE(HAVE_AS_EXPLICIT_RELOCS, 1,
2814   [Define if your assembler supports explicit relocations.])])
2815     gcc_GAS_CHECK_FEATURE([jsrdirect relocation support],
2816         gcc_cv_as_alpha_jsrdirect_relocs, [2,16,90],,
2817 [       .set nomacro
2818         .text
2819         ldq     $27, a($29)     !literal!1
2820         jsr     $26, ($27), a   !lituse_jsrdirect!1],,
2821     [AC_DEFINE(HAVE_AS_JSRDIRECT_RELOCS, 1,
2822   [Define if your assembler supports the lituse_jsrdirect relocation.])])
2823     ;;
2824
2825   cris-*-*)
2826     gcc_GAS_CHECK_FEATURE([-no-mul-bug-abort option],
2827       gcc_cv_as_cris_no_mul_bug,[2,15,91],
2828       [-no-mul-bug-abort], [.text],,
2829       [AC_DEFINE(HAVE_AS_NO_MUL_BUG_ABORT_OPTION, 1,
2830                 [Define if your assembler supports the -no-mul-bug-abort option.])])
2831     ;;
2832
2833   sparc*-*-*)
2834     gcc_GAS_CHECK_FEATURE([.register], gcc_cv_as_sparc_register_op,,,
2835       [.register %g2, #scratch],,
2836       [AC_DEFINE(HAVE_AS_REGISTER_PSEUDO_OP, 1,
2837                 [Define if your assembler supports .register.])])
2838
2839     gcc_GAS_CHECK_FEATURE([-relax option], gcc_cv_as_sparc_relax,,
2840       [-relax], [.text],,
2841       [AC_DEFINE(HAVE_AS_RELAX_OPTION, 1,
2842                 [Define if your assembler supports -relax option.])])
2843
2844     gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs],
2845       gcc_cv_as_sparc_ua_pcrel,,
2846       [-K PIC],
2847 [.text
2848 foo:
2849         nop
2850 .data
2851 .align 4
2852 .byte 0
2853 .uaword %r_disp32(foo)],
2854       [if test x$gcc_cv_ld != x \
2855        && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1; then
2856          gcc_cv_as_sparc_ua_pcrel=yes
2857        fi
2858        rm -f conftest],
2859       [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL, 1,
2860                 [Define if your assembler and linker support unaligned PC relative relocs.])
2861
2862       gcc_GAS_CHECK_FEATURE([unaligned pcrel relocs against hidden symbols],
2863         gcc_cv_as_sparc_ua_pcrel_hidden,,
2864         [-K PIC],
2865 [.data
2866 .align 4
2867 .byte 0x31
2868 .uaword %r_disp32(foo)
2869 .byte 0x32, 0x33, 0x34
2870 .global foo
2871 .hidden foo
2872 foo:
2873 .skip 4],
2874         [if test x$gcc_cv_ld != x && test x$gcc_cv_objdump != x \
2875          && $gcc_cv_ld -o conftest conftest.o -G > /dev/null 2>&1 \
2876          && $gcc_cv_objdump -s -j .data conftest 2> /dev/null \
2877             | grep ' 31000000 07323334' > /dev/null 2>&1; then
2878             if $gcc_cv_objdump -R conftest 2> /dev/null \
2879                | grep 'DISP32' > /dev/null 2>&1; then
2880                 :
2881             else
2882                 gcc_cv_as_sparc_ua_pcrel_hidden=yes
2883             fi
2884          fi
2885          rm -f conftest],
2886          [AC_DEFINE(HAVE_AS_SPARC_UA_PCREL_HIDDEN, 1,
2887                    [Define if your assembler and linker support unaligned PC relative relocs against hidden symbols.])])
2888     ]) # unaligned pcrel relocs
2889
2890     gcc_GAS_CHECK_FEATURE([offsetable %lo()],
2891       gcc_cv_as_sparc_offsetable_lo10,,
2892       [-xarch=v9],
2893 [.text
2894         or %g1, %lo(ab) + 12, %g1
2895         or %g1, %lo(ab + 12), %g1],
2896       [if test x$gcc_cv_objdump != x \
2897        && $gcc_cv_objdump -s -j .text conftest.o 2> /dev/null \
2898           | grep ' 82106000 82106000' > /dev/null 2>&1; then
2899          gcc_cv_as_sparc_offsetable_lo10=yes
2900        fi],
2901        [AC_DEFINE(HAVE_AS_OFFSETABLE_LO10, 1,
2902                  [Define if your assembler supports offsetable %lo().])])
2903     ;;
2904
2905 changequote(,)dnl
2906   i[34567]86-*-* | x86_64-*-*)
2907 changequote([,])dnl
2908     case $target_os in
2909       cygwin* | pe | mingw32*)
2910         # Used for DWARF 2 in PE
2911         gcc_GAS_CHECK_FEATURE([.secrel32 relocs],
2912           gcc_cv_as_ix86_pe_secrel32,
2913           [2,15,91],,
2914 [.text
2915 foo:    nop
2916 .data
2917         .secrel32 foo],
2918           [if test x$gcc_cv_ld != x \
2919            && $gcc_cv_ld -o conftest conftest.o > /dev/null 2>&1; then
2920              gcc_cv_as_ix86_pe_secrel32=yes
2921            fi
2922            rm -f conftest],
2923           [AC_DEFINE(HAVE_GAS_PE_SECREL32_RELOC, 1,
2924             [Define if your assembler and linker support 32-bit section relative relocs via '.secrel32 label'.])])
2925         ;;
2926     esac
2927
2928     gcc_GAS_CHECK_FEATURE([filds and fists mnemonics],
2929        gcc_cv_as_ix86_filds_fists,
2930       [2,9,0],, [filds mem; fists mem],,
2931       [AC_DEFINE(HAVE_GAS_FILDS_FISTS, 1,
2932         [Define if your assembler uses the new HImode fild and fist notation.])])
2933
2934     gcc_GAS_CHECK_FEATURE([cmov syntax],
2935       gcc_cv_as_ix86_cmov_sun_syntax,,,
2936       [cmovl.l %edx, %eax],,
2937       [AC_DEFINE(HAVE_AS_IX86_CMOV_SUN_SYNTAX, 1,
2938         [Define if your assembler supports the Sun syntax for cmov.])])
2939
2940     gcc_GAS_CHECK_FEATURE([ffreep mnemonic],
2941       gcc_cv_as_ix86_ffreep,,,
2942       [ffreep %st(1)],,
2943       [AC_DEFINE(HAVE_AS_IX86_FFREEP, 1,
2944         [Define if your assembler supports the ffreep mnemonic.])])
2945
2946     gcc_GAS_CHECK_FEATURE([sahf mnemonic],
2947       gcc_cv_as_ix86_sahf,,,
2948       [sahf],,
2949       [AC_DEFINE(HAVE_AS_IX86_SAHF, 1,
2950         [Define if your assembler supports the sahf mnemonic.])])
2951
2952     gcc_GAS_CHECK_FEATURE([different section symbol subtraction],
2953       gcc_cv_as_ix86_diff_sect_delta,,,
2954       [.section .rodata
2955 .L1:
2956         .long .L2-.L1
2957         .long .L3-.L1
2958         .text
2959 .L3:    nop
2960 .L2:    nop],,
2961       [AC_DEFINE(HAVE_AS_IX86_DIFF_SECT_DELTA, 1,
2962         [Define if your assembler supports the subtraction of symbols in different sections.])])
2963
2964     # This one is used unconditionally by i386.[ch]; it is to be defined
2965     # to 1 if the feature is present, 0 otherwise.
2966     gcc_GAS_CHECK_FEATURE([GOTOFF in data],
2967         gcc_cv_as_ix86_gotoff_in_data, [2,11,0],,
2968 [       .text
2969 .L0:
2970         nop
2971         .data
2972         .long .L0@GOTOFF])
2973     AC_DEFINE_UNQUOTED(HAVE_AS_GOTOFF_IN_DATA,
2974       [`if test $gcc_cv_as_ix86_gotoff_in_data = yes; then echo 1; else echo 0; fi`],
2975       [Define true if the assembler supports '.long foo@GOTOFF'.])
2976     ;;
2977
2978   ia64*-*-*)
2979     gcc_GAS_CHECK_FEATURE([ltoffx and ldxmov relocs],
2980         gcc_cv_as_ia64_ltoffx_ldxmov_relocs, [2,14,0],,
2981 [       .text
2982         addl r15 = @ltoffx(x#), gp
2983         ;;
2984         ld8.mov r16 = [[r15]], x#],,
2985     [AC_DEFINE(HAVE_AS_LTOFFX_LDXMOV_RELOCS, 1,
2986           [Define if your assembler supports ltoffx and ldxmov relocations.])])
2987
2988     ;;
2989
2990   powerpc*-*-*)
2991     case $target in
2992       *-*-aix*) conftest_s='    .machine "pwr5"
2993         .csect .text[[PR]]
2994         mfcr 3,128';;
2995       *-*-darwin*)
2996         gcc_GAS_CHECK_FEATURE([.machine directive support],
2997           gcc_cv_as_machine_directive,,,
2998           [     .machine ppc7400])
2999         if test x$gcc_cv_as_machine_directive != xyes; then
3000           echo "*** This target requires an assembler supporting \".machine\"" >&2
3001           echo you can get it from: ftp://gcc.gnu.org/pub/gcc/infrastructure/cctools-528.5.dmg >&2
3002           test x$build = x$target && exit 1
3003         fi
3004         conftest_s='    .text
3005         mfcr r3,128';;
3006       *) conftest_s='   .machine power4
3007         .text
3008         mfcr 3,128';;
3009     esac
3010
3011     gcc_GAS_CHECK_FEATURE([mfcr field support],
3012       gcc_cv_as_powerpc_mfcrf, [2,14,0],,
3013       [$conftest_s],,
3014       [AC_DEFINE(HAVE_AS_MFCRF, 1,
3015           [Define if your assembler supports mfcr field.])])
3016
3017     case $target in
3018       *-*-aix*) conftest_s='    .machine "pwr5"
3019         .csect .text[[PR]]
3020         popcntb 3,3';;
3021       *) conftest_s='   .machine power5
3022         .text
3023         popcntb 3,3';;
3024     esac
3025
3026     gcc_GAS_CHECK_FEATURE([popcntb support],
3027       gcc_cv_as_powerpc_popcntb, [2,17,0],,
3028       [$conftest_s],,
3029       [AC_DEFINE(HAVE_AS_POPCNTB, 1,
3030           [Define if your assembler supports popcntb field.])])
3031
3032     case $target in
3033       *-*-aix*) conftest_s='    .machine "pwr5x"
3034         .csect .text[[PR]]
3035         frin 1,1';;
3036       *) conftest_s='   .machine power5
3037         .text
3038         frin 1,1';;
3039     esac
3040
3041     gcc_GAS_CHECK_FEATURE([fp round support],
3042       gcc_cv_as_powerpc_fprnd, [2,17,0],,
3043       [$conftest_s],,
3044       [AC_DEFINE(HAVE_AS_FPRND, 1,
3045           [Define if your assembler supports fprnd.])])
3046
3047     case $target in
3048       *-*-aix*) conftest_s='    .machine "pwr6"
3049         .csect .text[[PR]]
3050         mffgpr 1,3';;
3051       *) conftest_s='   .machine power6
3052         .text
3053         mffgpr 1,3';;
3054     esac
3055
3056     gcc_GAS_CHECK_FEATURE([move fp gpr support],
3057       gcc_cv_as_powerpc_mfpgpr, [9,99,0],,
3058       [$conftest_s],,
3059       [AC_DEFINE(HAVE_AS_MFPGPR, 1,
3060           [Define if your assembler supports mffgpr and mftgpr.])])
3061
3062     case $target in
3063       *-*-aix*) conftest_s='    .csect .text[[PR]]
3064 LCF..0:
3065         addis 11,30,_GLOBAL_OFFSET_TABLE_-LCF..0@ha';;
3066       *-*-darwin*)
3067         conftest_s='    .text
3068 LCF0:
3069         addis r11,r30,_GLOBAL_OFFSET_TABLE_-LCF0@ha';;
3070       *) conftest_s='   .text
3071 .LCF0:
3072         addis 11,30,_GLOBAL_OFFSET_TABLE_-.LCF0@ha';;
3073     esac
3074
3075     gcc_GAS_CHECK_FEATURE([rel16 relocs],
3076       gcc_cv_as_powerpc_rel16, [2,17,0], -a32,
3077       [$conftest_s],,
3078       [AC_DEFINE(HAVE_AS_REL16, 1,
3079           [Define if your assembler supports R_PPC_REL16 relocs.])])
3080
3081     case $target in
3082       *-*-aix*) conftest_s='    .machine "pwr6"
3083         .csect .text[[PR]]
3084         cmpb 3,4,5';;
3085       *) conftest_s='   .machine power6
3086         .text
3087         cmpb 3,4,5';;
3088     esac
3089
3090     gcc_GAS_CHECK_FEATURE([compare bytes support],
3091       gcc_cv_as_powerpc_cmpb, [9,99,0], -a32,
3092       [$conftest_s],,
3093       [AC_DEFINE(HAVE_AS_CMPB, 1,
3094           [Define if your assembler supports cmpb.])])
3095
3096     case $target in
3097       *-*-aix*) conftest_s='    .machine "pwr6"
3098         .csect .text[[PR]]
3099         dadd 1,2,3';;
3100       *) conftest_s='   .machine power6
3101         .text
3102         dadd 1,2,3';;
3103     esac
3104
3105     gcc_GAS_CHECK_FEATURE([decimal float support],
3106       gcc_cv_as_powerpc_dfp, [9,99,0], -a32,
3107       [$conftest_s],,
3108       [AC_DEFINE(HAVE_AS_DFP, 1,
3109           [Define if your assembler supports DFP instructions.])])
3110
3111     case $target in
3112       *-*-aix*) conftest_s='    .machine "pwr7"
3113         .csect .text[[PR]]
3114         lxvd2x 1,2,3';;
3115       *) conftest_s='   .machine power7
3116         .text
3117         lxvd2x 1,2,3';;
3118     esac
3119
3120     gcc_GAS_CHECK_FEATURE([vector-scalar support],
3121       gcc_cv_as_powerpc_vsx, [9,99,0], -a32,
3122       [$conftest_s],,
3123       [AC_DEFINE(HAVE_AS_VSX, 1,
3124           [Define if your assembler supports VSX instructions.])])
3125
3126     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3127       gcc_cv_as_powerpc_gnu_attribute, [2,18,0],,
3128       [.gnu_attribute 4,1],,
3129       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3130           [Define if your assembler supports .gnu_attribute.])])
3131
3132     gcc_GAS_CHECK_FEATURE([tls marker support],
3133       gcc_cv_as_powerpc_tls_markers, [2,20,0],,
3134       [ bl __tls_get_addr(x@tlsgd)],,
3135       [AC_DEFINE(HAVE_AS_TLS_MARKERS, 1,
3136           [Define if your assembler supports arg info for __tls_get_addr.])])
3137     ;;
3138
3139   mips*-*-*)
3140     gcc_GAS_CHECK_FEATURE([explicit relocation support],
3141       gcc_cv_as_mips_explicit_relocs, [2,14,0],,
3142 [       lw $4,%gp_rel(foo)($4)],,
3143       [if test x$target_cpu_default = x
3144        then target_cpu_default=MASK_EXPLICIT_RELOCS
3145        else target_cpu_default="($target_cpu_default)|MASK_EXPLICIT_RELOCS"
3146        fi])
3147     gcc_GAS_CHECK_FEATURE([-mno-shared support],
3148       gcc_cv_as_mips_no_shared, [2,16,0], [-mno-shared], [nop],,
3149       [AC_DEFINE(HAVE_AS_NO_SHARED, 1,
3150                  [Define if the assembler understands -mno-shared.])])
3151
3152     gcc_GAS_CHECK_FEATURE([.gnu_attribute support],
3153       gcc_cv_as_mips_gnu_attribute, [2,18,0],,
3154       [.gnu_attribute 4,1],,
3155       [AC_DEFINE(HAVE_AS_GNU_ATTRIBUTE, 1,
3156           [Define if your assembler supports .gnu_attribute.])])
3157
3158     gcc_GAS_CHECK_FEATURE([.dtprelword support],
3159       gcc_cv_as_mips_dtprelword, [2,18,0],,
3160       [.section .tdata,"awT",@progbits
3161 x:
3162         .word 2
3163         .text
3164         .dtprelword x+0x8000],,
3165       [AC_DEFINE(HAVE_AS_DTPRELWORD, 1,
3166           [Define if your assembler supports .dtprelword.])])
3167     ;;
3168 esac
3169
3170 # Mips and HP-UX need the GNU assembler.
3171 # Linux on IA64 might be able to use the Intel assembler.
3172
3173 case "$target" in
3174   mips*-*-* | *-*-hpux* )
3175     if test x$gas_flag = xyes \
3176        || test x"$host" != x"$build" \
3177        || test ! -x "$gcc_cv_as" \
3178        || "$gcc_cv_as" -v < /dev/null 2>&1 | grep GNU > /dev/null; then
3179       :
3180     else
3181       echo "*** This configuration requires the GNU assembler" >&2
3182       exit 1
3183     fi
3184     ;;
3185 esac
3186
3187 # ??? Not all targets support dwarf2 debug_line, even within a version
3188 # of gas.  Moreover, we need to emit a valid instruction to trigger any
3189 # info to the output file.  So, as supported targets are added to gas 2.11,
3190 # add some instruction here to (also) show we expect this might work.
3191 # ??? Once 2.11 is released, probably need to add first known working
3192 # version to the per-target configury.
3193 case "$target" in
3194   i?86*-*-* | mips*-*-* | alpha*-*-* | powerpc*-*-* | sparc*-*-* | m68*-*-* \
3195   | x86_64*-*-* | hppa*-*-* | arm*-*-* \
3196   | xstormy16*-*-* | cris-*-* | crisv32-*-* | xtensa*-*-* | bfin-*-* | score*-*-* \
3197   | spu-*-* | fido*-*-* | m32c-*-*)
3198     insn="nop"
3199     ;;
3200   ia64*-*-* | s390*-*-*)
3201     insn="nop 0"
3202     ;;
3203   mmix-*-*)
3204     insn="swym 0"
3205     ;;
3206 esac
3207 if test x"$insn" != x; then
3208  conftest_s="\
3209         .file 1 \"conftest.s\"
3210         .loc 1 3 0
3211         $insn"
3212  gcc_GAS_CHECK_FEATURE([dwarf2 debug_line support],
3213   gcc_cv_as_dwarf2_debug_line,
3214   [elf,2,11,0],, [$conftest_s],
3215   [if test x$gcc_cv_objdump != x \
3216    && $gcc_cv_objdump -h conftest.o 2> /dev/null \
3217       | grep debug_line > /dev/null 2>&1; then
3218      gcc_cv_as_dwarf2_debug_line=yes
3219    fi])
3220
3221 # The .debug_line file table must be in the exact order that
3222 # we specified the files, since these indices are also used
3223 # by DW_AT_decl_file.  Approximate this test by testing if
3224 # the assembler bitches if the same index is assigned twice.
3225  gcc_GAS_CHECK_FEATURE([buggy dwarf2 .file directive],
3226   gcc_cv_as_dwarf2_file_buggy,,,
3227 [       .file 1 "foo.s"
3228         .file 1 "bar.s"])
3229
3230  if test $gcc_cv_as_dwarf2_debug_line = yes \
3231  && test $gcc_cv_as_dwarf2_file_buggy = no; then
3232         AC_DEFINE(HAVE_AS_DWARF2_DEBUG_LINE, 1,
3233   [Define if your assembler supports dwarf2 .file/.loc directives,
3234    and preserves file table indices exactly as given.])
3235  fi
3236
3237  gcc_GAS_CHECK_FEATURE([--gdwarf2 option],
3238   gcc_cv_as_gdwarf2_flag,
3239   [elf,2,11,0], [--gdwarf2], [$insn],,
3240   [AC_DEFINE(HAVE_AS_GDWARF2_DEBUG_FLAG, 1,
3241 [Define if your assembler supports the --gdwarf2 option.])])
3242
3243  gcc_GAS_CHECK_FEATURE([--gstabs option],
3244   gcc_cv_as_gstabs_flag,
3245   [elf,2,11,0], [--gstabs], [$insn],
3246   [# The native Solaris 9/Intel assembler doesn't understand --gstabs
3247    # and warns about it, but still exits successfully.  So check for
3248    # this.
3249    if AC_TRY_COMMAND([$gcc_cv_as --gstabs -o conftest.o conftest.s 2>&1 | grep -i warning > /dev/null])
3250    then :
3251    else gcc_cv_as_gstabs_flag=yes
3252    fi],
3253   [AC_DEFINE(HAVE_AS_GSTABS_DEBUG_FLAG, 1,
3254 [Define if your assembler supports the --gstabs option.])])
3255
3256  gcc_GAS_CHECK_FEATURE([--debug-prefix-map option],
3257   gcc_cv_as_debug_prefix_map_flag,
3258   [2,18,0], [--debug-prefix-map /a=/b], [$insn],,
3259   [AC_DEFINE(HAVE_AS_DEBUG_PREFIX_MAP, 1,
3260 [Define if your assembler supports the --debug-prefix-map option.])])
3261 fi
3262
3263 gcc_GAS_CHECK_FEATURE([.lcomm with alignment], gcc_cv_as_lcomm_with_alignment,
3264  ,,
3265 [.lcomm bar,4,16],,
3266 [AC_DEFINE(HAVE_GAS_LCOMM_WITH_ALIGNMENT, 1,
3267   [Define if your assembler supports .lcomm with an alignment field.])])
3268
3269 AC_CACHE_CHECK([assembler for tolerance to line number 0],
3270  [gcc_cv_as_line_zero],
3271  [gcc_cv_as_line_zero=no
3272   if test $in_tree_gas = yes; then
3273     gcc_GAS_VERSION_GTE_IFELSE(2, 16, 91, [gcc_cv_as_line_zero=yes])
3274   elif test "x$gcc_cv_as" != x; then
3275     { echo '# 1 "test.s" 1'; echo '# 0 "" 2'; } > conftest.s
3276     if AC_TRY_COMMAND([$gcc_cv_as -o conftest.o conftest.s >&AS_MESSAGE_LOG_FD 2>conftest.out]) &&
3277        test "x`cat conftest.out`" = x
3278     then
3279       gcc_cv_as_line_zero=yes
3280     else
3281       echo "configure: failed program was" >&AS_MESSAGE_LOG_FD
3282       cat conftest.s >&AS_MESSAGE_LOG_FD
3283       echo "configure: error output was" >&AS_MESSAGE_LOG_FD
3284       cat conftest.out >&AS_MESSAGE_LOG_FD
3285     fi
3286     rm -f conftest.o conftest.s conftest.out
3287   fi])
3288 if test "x$gcc_cv_as_line_zero" = xyes; then
3289   AC_DEFINE([HAVE_AS_LINE_ZERO], 1,
3290 [Define if the assembler won't complain about a line such as # 0 "" 2.])
3291 fi
3292
3293 AC_MSG_CHECKING(linker PT_GNU_EH_FRAME support)
3294 gcc_cv_ld_eh_frame_hdr=no
3295 if test $in_tree_ld = yes ; then
3296   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 \
3297      && test $in_tree_ld_is_elf = yes; then
3298     gcc_cv_ld_eh_frame_hdr=yes
3299   fi
3300 elif test x$gcc_cv_ld != x; then
3301         # Check if linker supports --eh-frame-hdr option
3302         if $gcc_cv_ld --help 2>/dev/null | grep eh-frame-hdr > /dev/null; then
3303                 gcc_cv_ld_eh_frame_hdr=yes
3304         fi
3305 fi
3306 GCC_TARGET_TEMPLATE([HAVE_LD_EH_FRAME_HDR])
3307 if test x"$gcc_cv_ld_eh_frame_hdr" = xyes; then
3308         AC_DEFINE(HAVE_LD_EH_FRAME_HDR, 1,
3309 [Define if your linker supports --eh-frame-hdr option.])
3310 fi
3311 AC_MSG_RESULT($gcc_cv_ld_eh_frame_hdr)
3312
3313 AC_MSG_CHECKING(linker position independent executable support)
3314 gcc_cv_ld_pie=no
3315 if test $in_tree_ld = yes ; then
3316   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 \
3317      && test $in_tree_ld_is_elf = yes; then
3318     gcc_cv_ld_pie=yes
3319   fi
3320 elif test x$gcc_cv_ld != x; then
3321         # Check if linker supports -pie option
3322         if $gcc_cv_ld --help 2>/dev/null | grep -- -pie > /dev/null; then
3323                 gcc_cv_ld_pie=yes
3324         fi
3325 fi
3326 if test x"$gcc_cv_ld_pie" = xyes; then
3327         AC_DEFINE(HAVE_LD_PIE, 1,
3328 [Define if your linker supports -pie option.])
3329 fi
3330 AC_MSG_RESULT($gcc_cv_ld_pie)
3331
3332 AC_MSG_CHECKING(linker EH-compatible garbage collection of sections)
3333 gcc_cv_ld_eh_gc_sections=no
3334 if test $in_tree_ld = yes ; then
3335   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 \
3336      && test $in_tree_ld_is_elf = yes; then
3337     gcc_cv_ld_eh_gc_sections=yes
3338   fi
3339 elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x -a x$gcc_cv_objdump != x ; then
3340   cat > conftest.s <<EOF
3341         .section        .text
3342 .globl _start
3343         .type _start, @function
3344 _start:
3345         .long foo
3346         .size _start, .-_start
3347         .section        .text.foo,"ax",@progbits
3348         .type foo, @function
3349 foo:
3350         .long 0
3351         .size foo, .-foo
3352         .section        .gcc_except_table.foo,"a",@progbits
3353 .L0:
3354         .long 0
3355         .section        .eh_frame,"a",@progbits
3356         .long .L0
3357 EOF
3358   if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3359     if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3360          | grep "gc-sections option ignored" > /dev/null; then
3361       gcc_cv_ld_eh_gc_sections=no
3362     elif $gcc_cv_objdump -h conftest | grep gcc_except_table > /dev/null; then
3363       gcc_cv_ld_eh_gc_sections=yes
3364       # If no COMDAT groups, the compiler will emit .gnu.linkonce.t. sections.
3365       if test x$gcc_cv_as_comdat_group != xyes; then
3366         gcc_cv_ld_eh_gc_sections=no
3367         cat > conftest.s <<EOF
3368         .section        .text
3369 .globl _start
3370         .type _start, @function
3371 _start:
3372         .long foo
3373         .size _start, .-_start
3374         .section        .gnu.linkonce.t.foo,"ax",@progbits
3375         .type foo, @function
3376 foo:
3377         .long 0
3378         .size foo, .-foo
3379         .section        .gcc_except_table.foo,"a",@progbits
3380 .L0:
3381         .long 0
3382         .section        .eh_frame,"a",@progbits
3383         .long .L0
3384 EOF
3385         if $gcc_cv_as -o conftest.o conftest.s > /dev/null 2>&1; then
3386           if $gcc_cv_ld -o conftest conftest.o --entry=_start --gc-sections 2>&1 \
3387                | grep "gc-sections option ignored" > /dev/null; then
3388             gcc_cv_ld_eh_gc_sections=no
3389           elif $gcc_cv_objdump -h conftest | grep gcc_except_table > /dev/null; then
3390             gcc_cv_ld_eh_gc_sections=yes
3391           fi
3392         fi
3393       fi
3394     fi
3395   fi
3396   rm -f conftest.s conftest.o conftest
3397 fi
3398 case "$target" in
3399   hppa*-*-linux*)
3400     # ??? This apparently exposes a binutils bug with PC-relative relocations.
3401     gcc_cv_ld_eh_gc_sections=no
3402     ;;
3403 esac
3404 if test x$gcc_cv_ld_eh_gc_sections = xyes; then
3405         AC_DEFINE(HAVE_LD_EH_GC_SECTIONS, 1,
3406   [Define if your linker supports garbage collection of
3407    sections in presence of EH frames.])
3408 fi
3409 AC_MSG_RESULT($gcc_cv_ld_eh_gc_sections)
3410
3411 # --------
3412 # UNSORTED
3413 # --------
3414
3415 AC_CACHE_CHECK(linker --as-needed support,
3416 gcc_cv_ld_as_needed,
3417 [gcc_cv_ld_as_needed=no
3418 if test $in_tree_ld = yes ; then
3419   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 \
3420      && test $in_tree_ld_is_elf = yes; then
3421     gcc_cv_ld_as_needed=yes
3422   fi
3423 elif test x$gcc_cv_ld != x; then
3424         # Check if linker supports --as-needed and --no-as-needed options
3425         if $gcc_cv_ld --help 2>/dev/null | grep as-needed > /dev/null; then
3426                 gcc_cv_ld_as_needed=yes
3427         fi
3428 fi
3429 ])
3430 if test x"$gcc_cv_ld_as_needed" = xyes; then
3431         AC_DEFINE(HAVE_LD_AS_NEEDED, 1,
3432 [Define if your linker supports --as-needed and --no-as-needed options.])
3433 fi
3434
3435 case "$target:$tm_file" in
3436   powerpc64*-*-linux* | powerpc*-*-linux*rs6000/biarch64.h*)
3437     AC_CACHE_CHECK(linker support for omitting dot symbols,
3438     gcc_cv_ld_no_dot_syms,
3439     [gcc_cv_ld_no_dot_syms=no
3440     if test $in_tree_ld = yes ; then
3441       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
3442         gcc_cv_ld_no_dot_syms=yes
3443       fi
3444     elif test x$gcc_cv_as != x -a x$gcc_cv_ld != x ; then
3445       cat > conftest1.s <<EOF
3446         .text
3447         bl .foo
3448 EOF
3449       cat > conftest2.s <<EOF
3450         .section ".opd","aw"
3451         .align 3
3452         .globl foo
3453         .type foo,@function
3454 foo:
3455         .quad .LEfoo,.TOC.@tocbase,0
3456         .text
3457 .LEfoo:
3458         blr
3459         .size foo,.-.LEfoo
3460 EOF
3461       if $gcc_cv_as -a64 -o conftest1.o conftest1.s > /dev/null 2>&1 \
3462          && $gcc_cv_as -a64 -o conftest2.o conftest2.s > /dev/null 2>&1 \
3463          && $gcc_cv_ld -melf64ppc -o conftest conftest1.o conftest2.o > /dev/null 2>&1; then
3464         gcc_cv_ld_no_dot_syms=yes
3465       fi
3466       rm -f conftest conftest1.o conftest2.o conftest1.s conftest2.s
3467     fi
3468     ])
3469     if test x"$gcc_cv_ld_no_dot_syms" = xyes; then
3470       AC_DEFINE(HAVE_LD_NO_DOT_SYMS, 1,
3471     [Define if your PowerPC64 linker only needs function descriptor syms.])
3472     fi
3473     ;;
3474 esac
3475
3476 AC_CACHE_CHECK(linker --sysroot support,
3477   gcc_cv_ld_sysroot,
3478   [gcc_cv_ld_sysroot=no
3479   if test $in_tree_ld = yes ; then
3480       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
3481         gcc_cv_ld_sysroot=yes
3482       fi
3483   elif test x$gcc_cv_ld != x; then 
3484     if $gcc_cv_ld --help 2>/dev/null | grep sysroot > /dev/null; then
3485       gcc_cv_ld_sysroot=yes
3486     fi
3487   fi])
3488 if test x"$gcc_cv_ld_sysroot" = xyes; then
3489   AC_DEFINE(HAVE_LD_SYSROOT, 1,
3490   [Define if your linker supports --sysroot.])
3491 fi        
3492
3493 if test x$with_sysroot = x && test x$host = x$target \
3494    && test "$prefix" != "/usr" && test "x$prefix" != "x$local_prefix" \
3495    && test "$prefix" != "NONE"; then
3496   AC_DEFINE_UNQUOTED(PREFIX_INCLUDE_DIR, "$prefix/include",
3497 [Define to PREFIX/include if cpp should also search that directory.])
3498 fi
3499
3500 # Test for stack protector support in target C library.
3501 AC_CACHE_CHECK(__stack_chk_fail in target C library,
3502       gcc_cv_libc_provides_ssp,
3503       [gcc_cv_libc_provides_ssp=no
3504     case "$target" in
3505        *-*-linux* | *-*-kfreebsd*-gnu | *-*-knetbsd*-gnu)
3506       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
3507         if test "x$with_sysroot" = x; then
3508           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
3509         elif test "x$with_build_sysroot" != "x"; then
3510           glibc_header_dir="${with_build_sysroot}/usr/include"
3511         elif test "x$with_sysroot" = xyes; then
3512           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
3513         else
3514           glibc_header_dir="${with_sysroot}/usr/include"
3515         fi
3516       else
3517         glibc_header_dir=/usr/include
3518       fi
3519       # glibc 2.4 and later provides __stack_chk_fail and
3520       # either __stack_chk_guard, or TLS access to stack guard canary.
3521       if test -f $glibc_header_dir/features.h \
3522          && $EGREP '^@<:@       @:>@*#[         ]*define[       ]+__GNU_LIBRARY__[      ]+([1-9][0-9]|[6-9])' \
3523             $glibc_header_dir/features.h > /dev/null; then
3524         if $EGREP '^@<:@        @:>@*#[         ]*define[       ]+__GLIBC__[    ]+([1-9][0-9]|[3-9])' \
3525            $glibc_header_dir/features.h > /dev/null; then
3526           gcc_cv_libc_provides_ssp=yes
3527         elif $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__GLIBC__[    ]+2' \
3528              $glibc_header_dir/features.h > /dev/null \
3529              && $EGREP '^@<:@   @:>@*#[         ]*define[       ]+__GLIBC_MINOR__[      ]+([1-9][0-9]|[4-9])' \
3530              $glibc_header_dir/features.h > /dev/null; then
3531           gcc_cv_libc_provides_ssp=yes
3532         elif $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__UCLIBC__[   ]+1' \
3533              $glibc_header_dir/features.h > /dev/null && \
3534              test -f $glibc_header_dir/bits/uClibc_config.h && \
3535              $EGREP '^@<:@      @:>@*#[         ]*define[       ]+__UCLIBC_HAS_SSP__[   ]+1' \
3536              $glibc_header_dir/bits/uClibc_config.h > /dev/null; then
3537           gcc_cv_libc_provides_ssp=yes
3538         fi
3539       fi
3540         ;;
3541        *-*-gnu*)
3542          # Avoid complicated tests (see
3543          # <http://gcc.gnu.org/ml/gcc/2008-10/msg00130.html>) and for now
3544          # simply assert that glibc does provide this, which is true for all
3545          # realistically usable GNU/Hurd configurations.
3546          gcc_cv_libc_provides_ssp=yes;;
3547        *-*-darwin*)
3548          AC_CHECK_FUNC(__stack_chk_fail,[gcc_cv_libc_provides_ssp=yes],
3549            [echo "no __stack_chk_fail on this target"])
3550         ;;
3551   *) gcc_cv_libc_provides_ssp=no ;;
3552     esac])
3553
3554 if test x$gcc_cv_libc_provides_ssp = xyes; then
3555   AC_DEFINE(TARGET_LIBC_PROVIDES_SSP, 1,
3556             [Define if your target C library provides stack protector support])
3557 fi
3558
3559 # Check if TFmode long double should be used by default or not.
3560 # Some glibc targets used DFmode long double, but with glibc 2.4
3561 # and later they can use TFmode.
3562 case "$target" in
3563   powerpc*-*-linux* | \
3564   powerpc*-*-gnu* | \
3565   sparc*-*-linux* | \
3566   s390*-*-linux* | \
3567   alpha*-*-linux*)
3568     AC_ARG_WITH(long-double-128,
3569 [  --with-long-double-128  Use 128-bit long double by default.],
3570       gcc_cv_target_ldbl128="$with_long_double_128",
3571       [gcc_cv_target_ldbl128=no
3572       if test x$host != x$target || test "x$TARGET_SYSTEM_ROOT" != x; then
3573         if test "x$with_sysroot" = x; then
3574           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-include"
3575         elif test "x$with_build_sysroot" != "x"; then
3576           glibc_header_dir="${with_build_sysroot}/usr/include"
3577         elif test "x$with_sysroot" = xyes; then
3578           glibc_header_dir="${exec_prefix}/${target_noncanonical}/sys-root/usr/include"
3579         else
3580           glibc_header_dir="${with_sysroot}/usr/include"
3581         fi
3582       else
3583         glibc_header_dir=/usr/include
3584       fi
3585 changequote(,)dnl
3586       grep '^[  ]*#[    ]*define[       ][      ]*__LONG_DOUBLE_MATH_OPTIONAL' \
3587         $glibc_header_dir/bits/wordsize.h > /dev/null 2>&1 \
3588       && gcc_cv_target_ldbl128=yes
3589 changequote([,])dnl
3590       ])
3591     ;;
3592 esac
3593 if test x$gcc_cv_target_ldbl128 = xyes; then
3594   AC_DEFINE(TARGET_DEFAULT_LONG_DOUBLE_128, 1,
3595             [Define if TFmode long double should be the default])
3596 fi
3597
3598 # Find out what GC implementation we want, or may, use.
3599 AC_ARG_WITH(gc,
3600 [  --with-gc={page,zone}   choose the garbage collection mechanism to use
3601                           with the compiler],
3602 [case "$withval" in
3603   page)
3604     GGC=ggc-$withval
3605     ;;
3606   zone)
3607     GGC=ggc-$withval
3608     AC_DEFINE(GGC_ZONE, 1, [Define if the zone collector is in use])
3609     ;;
3610   *)
3611     AC_MSG_ERROR([$withval is an invalid option to --with-gc])
3612     ;;
3613 esac],
3614 [GGC=ggc-page])
3615 AC_SUBST(GGC)
3616 echo "Using $GGC for garbage collection."
3617
3618 # Use the system's zlib library.
3619 zlibdir=-L../zlib
3620 zlibinc="-I\$(srcdir)/../zlib"
3621 AC_ARG_WITH(system-zlib,
3622 [  --with-system-zlib      use installed libz],
3623 zlibdir=
3624 zlibinc=
3625 )
3626 AC_SUBST(zlibdir)
3627 AC_SUBST(zlibinc)
3628
3629 dnl Very limited version of automake's enable-maintainer-mode
3630
3631 AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
3632   dnl maintainer-mode is disabled by default
3633   AC_ARG_ENABLE(maintainer-mode,
3634 [  --enable-maintainer-mode
3635                           enable make rules and dependencies not useful
3636                           (and sometimes confusing) to the casual installer],
3637       maintainer_mode=$enableval,
3638       maintainer_mode=no)
3639
3640 AC_MSG_RESULT($maintainer_mode)
3641
3642 if test "$maintainer_mode" = "yes"; then
3643   MAINT=''
3644 else
3645   MAINT='#'
3646 fi
3647 AC_SUBST(MAINT)dnl
3648
3649 # --------------
3650 # Language hooks
3651 # --------------
3652
3653 # Make empty files to contain the specs and options for each language.
3654 # Then add #include lines to for a compiler that has specs and/or options.
3655
3656 subdirs=
3657 lang_opt_files=
3658 lang_specs_files=
3659 lang_tree_files=
3660 # These (without "all_") are set in each config-lang.in.
3661 # `language' must be a single word so is spelled singularly.
3662 all_languages=
3663 all_compilers=
3664 all_outputs='Makefile gccbug'
3665 # List of language makefile fragments.
3666 all_lang_makefrags=
3667 # List of language subdirectory makefiles.  Deprecated.
3668 all_lang_makefiles=
3669 # Additional files for gengtype
3670 all_gtfiles="$target_gtfiles"
3671
3672 # These are the languages that are set in --enable-languages,
3673 # and are available in the GCC tree.
3674 all_selected_languages=
3675
3676 # Add the language fragments.
3677 # Languages are added via two mechanisms.  Some information must be
3678 # recorded in makefile variables, these are defined in config-lang.in.
3679 # We accumulate them and plug them into the main Makefile.
3680 # The other mechanism is a set of hooks for each of the main targets
3681 # like `clean', `install', etc.
3682
3683 language_hooks="Make-hooks"
3684
3685 for lang in ${srcdir}/*/config-lang.in
3686 do
3687 changequote(,)dnl
3688         test "$lang" = "${srcdir}/*/config-lang.in" && continue
3689
3690         lang_alias=`sed -n -e 's,^language=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^language=\([^   ]*\).*$,\1,p' $lang`
3691         if test "x$lang_alias" = x
3692         then
3693               echo "$lang doesn't set \$language." 1>&2
3694               exit 1
3695         fi
3696         subdir="`echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`"
3697         subdirs="$subdirs $subdir"
3698
3699         # $gcc_subdir is where the gcc integration files are to be found
3700         # for a language, both for internal compiler purposes (compiler
3701         # sources implementing front-end to GCC tree converters), and for
3702         # build infrastructure purposes (Make-lang.in, etc.)
3703         #
3704         # This will be <subdir> (relative to $srcdir) if a line like 
3705         # gcc_subdir="<subdir>" or gcc_subdir=<subdir>
3706         # is found in <langdir>/config-lang.in, and will remain <langdir>
3707         # otherwise.
3708         #
3709         # Except for the language alias (fetched above), the regular
3710         # "config-lang.in" contents are always retrieved from $gcc_subdir,
3711         # so a <langdir>/config-lang.in setting gcc_subdir typically sets
3712         # only this and the language alias.
3713
3714         gcc_subdir=`sed -n -e 's,^gcc_subdir=['"'"'"'"]\(.*\)["'"'"'"'].*$,\1,p' -e 's,^gcc_subdir=\([^   ]*\).*$,\1,p' $lang`
3715         if [ "$gcc_subdir" = "" ]; then
3716            gcc_subdir="$subdir"
3717         fi
3718
3719         case ",$enable_languages," in
3720         *,$lang_alias,*)
3721             all_selected_languages="$all_selected_languages $lang_alias"
3722             if test -f $srcdir/$gcc_subdir/lang-specs.h; then
3723                 lang_specs_files="$lang_specs_files $srcdir/$gcc_subdir/lang-specs.h"
3724             fi
3725             ;;
3726         esac
3727 changequote([,])dnl
3728
3729         language=
3730         boot_language=
3731         compilers=
3732         outputs=
3733         gtfiles=
3734         subdir_requires=
3735         . ${srcdir}/$gcc_subdir/config-lang.in
3736         if test "x$language" = x
3737         then
3738                 echo "${srcdir}/$gcc_subdir/config-lang.in doesn't set \$language." 1>&2
3739                 exit 1
3740         fi
3741
3742         ok=:
3743         case ",$enable_languages," in
3744                 *,$lang_alias,*) ;;
3745                 *)
3746                         for i in $subdir_requires; do
3747                                 test -f "${srcdir}/$i/config-lang.in" && continue
3748                                 ok=false
3749                                 break
3750                         done
3751                 ;;
3752         esac
3753         $ok || continue
3754
3755         all_lang_makefrags="$all_lang_makefrags \$(srcdir)/$gcc_subdir/Make-lang.in"
3756         if test -f $srcdir/$gcc_subdir/lang.opt; then
3757             lang_opt_files="$lang_opt_files $srcdir/$gcc_subdir/lang.opt"
3758         fi
3759         if test -f $srcdir/$gcc_subdir/$subdir-tree.def; then
3760             lang_tree_files="$lang_tree_files $srcdir/$gcc_subdir/$subdir-tree.def"
3761         fi
3762         if test -f ${srcdir}/$gcc_subdir/Makefile.in
3763                 then all_lang_makefiles="$gcc_subdir/Makefile"
3764         fi
3765         all_languages="$all_languages $language"
3766         all_compilers="$all_compilers $compilers"
3767         all_outputs="$all_outputs $outputs"
3768         all_gtfiles="$all_gtfiles [[$subdir]] $gtfiles"
3769 done
3770
3771 # Pick up gtfiles for c
3772 gtfiles=
3773 . ${srcdir}/c-config-lang.in
3774 all_gtfiles="$all_gtfiles [[c]] $gtfiles"
3775
3776 check_languages=
3777 for language in $all_selected_languages
3778 do
3779         check_languages="$check_languages check-$language"
3780 done
3781
3782 # We link each language in with a set of hooks, reached indirectly via
3783 # lang.${target}.  Only do so for selected languages.
3784
3785 rm -f Make-hooks
3786 touch Make-hooks
3787 target_list="all.cross start.encap rest.encap tags \
3788         install-common install-man install-info install-pdf dvi pdf \
3789         html uninstall info man srcextra srcman srcinfo \
3790         mostlyclean clean distclean maintainer-clean"
3791
3792 for t in $target_list
3793 do
3794         x=
3795         for lang in $all_selected_languages
3796         do
3797                 x="$x $lang.$t"
3798         done
3799         echo "lang.$t: $x" >> Make-hooks
3800 done
3801
3802 # --------
3803 # UNSORTED
3804 # --------
3805
3806 # Create .gdbinit.
3807
3808 echo "dir ." > .gdbinit
3809 echo "dir ${srcdir}" >> .gdbinit
3810 if test x$gdb_needs_out_file_path = xyes
3811 then
3812         echo "dir ${srcdir}/config/"`dirname ${out_file}` >> .gdbinit
3813 fi
3814 if test "x$subdirs" != x; then
3815         for s in $subdirs
3816         do
3817                 echo "dir ${srcdir}/$s" >> .gdbinit
3818         done
3819 fi
3820 echo "source ${srcdir}/gdbinit.in" >> .gdbinit
3821
3822 gcc_tooldir='$(libsubdir)/$(libsubdir_to_prefix)$(target_noncanonical)'
3823 AC_SUBST(gcc_tooldir)
3824 AC_SUBST(dollar)
3825
3826 # Find a directory in which to install a shared libgcc.
3827
3828 AC_ARG_ENABLE(version-specific-runtime-libs,
3829 [  --enable-version-specific-runtime-libs
3830                           specify that runtime libraries should be
3831                           installed in a compiler-specific directory])
3832
3833 AC_ARG_WITH(slibdir,
3834 [  --with-slibdir=DIR      shared libraries in DIR [[LIBDIR]]],
3835 slibdir="$with_slibdir",
3836 if test "${enable_version_specific_runtime_libs+set}" = set; then
3837   slibdir='$(libsubdir)'
3838 elif test "$host" != "$target"; then
3839   slibdir='$(build_tooldir)/lib'
3840 else
3841   slibdir='$(libdir)'
3842 fi)
3843 AC_SUBST(slibdir)
3844
3845 AC_ARG_WITH(datarootdir,
3846 [  --with-datarootdir=DIR  Use DIR as the data root [[PREFIX/share]]],
3847 datarootdir="\${prefix}/$with_datarootdir",
3848 datarootdir='$(prefix)/share')
3849 AC_SUBST(datarootdir)
3850
3851 AC_ARG_WITH(docdir,
3852 [  --with-docdir=DIR       Install documentation in DIR [[DATAROOTDIR]]],
3853 docdir="\${prefix}/$with_docdir",
3854 docdir='$(datarootdir)')
3855 AC_SUBST(docdir)
3856
3857 AC_ARG_WITH(htmldir,
3858 [  --with-htmldir=DIR      html documentation in in DIR [[DOCDIR]]],
3859 htmldir="\${prefix}/$with_htmldir",
3860 htmldir='$(docdir)')
3861 AC_SUBST(htmldir)
3862
3863 # Substitute configuration variables
3864 AC_SUBST(subdirs)
3865 AC_SUBST(srcdir)
3866 AC_SUBST(all_compilers)
3867 AC_SUBST(all_gtfiles)
3868 AC_SUBST(all_lang_makefrags)
3869 AC_SUBST(all_lang_makefiles)
3870 AC_SUBST(all_languages)
3871 AC_SUBST(all_selected_languages)
3872 AC_SUBST(build_exeext)
3873 AC_SUBST(build_install_headers_dir)
3874 AC_SUBST(build_xm_file_list)
3875 AC_SUBST(build_xm_include_list)
3876 AC_SUBST(build_xm_defines)
3877 AC_SUBST(build_file_translate)
3878 AC_SUBST(check_languages)
3879 AC_SUBST(cpp_install_dir)
3880 AC_SUBST(xmake_file)
3881 AC_SUBST(tmake_file)
3882 AC_SUBST(extra_gcc_objs)
3883 AC_SUBST(extra_headers_list)
3884 AC_SUBST(extra_objs)
3885 AC_SUBST(extra_parts)
3886 AC_SUBST(extra_passes)
3887 AC_SUBST(extra_programs)
3888 AC_SUBST(float_h_file)
3889 AC_SUBST(gcc_config_arguments)
3890 AC_SUBST(gcc_gxx_include_dir)
3891 AC_SUBST(host_exeext)
3892 AC_SUBST(host_xm_file_list)
3893 AC_SUBST(host_xm_include_list)
3894 AC_SUBST(host_xm_defines)
3895 AC_SUBST(out_host_hook_obj)
3896 AC_SUBST(install)
3897 AC_SUBST(lang_opt_files)
3898 AC_SUBST(lang_specs_files)
3899 AC_SUBST(lang_tree_files)
3900 AC_SUBST(local_prefix)
3901 AC_SUBST(md_file)
3902 AC_SUBST(objc_boehm_gc)
3903 AC_SUBST(out_file)
3904 AC_SUBST(out_object_file)
3905 AC_SUBST(thread_file)
3906 AC_SUBST(tm_file_list)
3907 AC_SUBST(tm_include_list)
3908 AC_SUBST(tm_defines)
3909 AC_SUBST(tm_p_file_list)
3910 AC_SUBST(tm_p_include_list)
3911 AC_SUBST(xm_file_list)
3912 AC_SUBST(xm_include_list)
3913 AC_SUBST(xm_defines)
3914 AC_SUBST(use_gcc_stdint)
3915 AC_SUBST(c_target_objs)
3916 AC_SUBST(cxx_target_objs)
3917 AC_SUBST(fortran_target_objs)
3918 AC_SUBST(target_cpu_default)
3919
3920 AC_SUBST_FILE(language_hooks)
3921
3922 # Echo link setup.
3923 if test x${build} = x${host} ; then
3924   if test x${host} = x${target} ; then
3925     echo "Links are now set up to build a native compiler for ${target}." 1>&2
3926   else
3927     echo "Links are now set up to build a cross-compiler" 1>&2
3928     echo " from ${host} to ${target}." 1>&2
3929   fi
3930 else
3931   if test x${host} = x${target} ; then
3932     echo "Links are now set up to build (on ${build}) a native compiler" 1>&2
3933     echo " for ${target}." 1>&2
3934   else
3935     echo "Links are now set up to build (on ${build}) a cross-compiler" 1>&2
3936     echo " from ${host} to ${target}." 1>&2
3937   fi
3938 fi
3939
3940 AC_ARG_VAR(GMPLIBS,[How to link GMP])
3941 AC_ARG_VAR(GMPINC,[How to find GMP include files])
3942
3943 AC_ARG_VAR(PPLLIBS,[How to link PPL])
3944 AC_ARG_VAR(PPLINC,[How to find PPL include files])
3945
3946 AC_ARG_VAR(CLOOGLIBS,[How to link CLOOG])
3947 AC_ARG_VAR(CLOOGINC,[How to find CLOOG include files])
3948 if test "x${CLOOGLIBS}" != "x" ; then 
3949    AC_DEFINE(HAVE_cloog, 1, [Define if cloog is in use.])
3950 fi
3951
3952 # Check for plugin support
3953 AC_ARG_ENABLE(plugin,
3954 [  --enable-plugin         enable plugin support],
3955 enable_plugin=$enableval,
3956 enable_plugin=yes; default_plugin=yes)
3957
3958 pluginlibs=
3959 if test x"$enable_plugin" = x"yes"; then
3960   # Check that the host supports -rdynamic and -ldl
3961   have_rdynamic=no
3962   have_dl=no
3963   saved_LDFLAGS="$LDFLAGS"
3964   saved_LIBS="$LIBS"
3965   LIBS=
3966
3967   # Check -rdynamic
3968   LDFLAGS="$LDFLAGS -rdynamic"
3969   AC_MSG_CHECKING([for -rdynamic])
3970   AC_TRY_LINK([],[return 0;],
3971     [AC_MSG_RESULT([yes]); have_rdynamic=yes],
3972     [AC_MSG_RESULT([no])])
3973   if test x"$have_rdynamic" = x"yes" ; then
3974     pluginlibs="-rdynamic"
3975   fi
3976
3977   # Check -ldl
3978   LDFLAGS="$LDFLAGS -ldl"
3979   AC_MSG_CHECKING([for -ldl])
3980   AC_TRY_LINK(
3981     [#include <dlfcn.h>],
3982     [volatile int f = 0; if (f) dlopen ("dummy", 0);],
3983     [AC_MSG_RESULT([yes]); have_dl=yes],
3984     [AC_MSG_RESULT([no])])
3985   if test x"$have_dl" = x"yes"; then
3986     pluginlibs="$pluginlibs -ldl"
3987   fi
3988
3989   # Check that we can build shared objects with -fPIC -shared
3990   LDFLAGS="$LDFLAGS -fPIC -shared"
3991   AC_MSG_CHECKING([for -fPIC -shared])
3992   AC_TRY_LINK(
3993     [extern int X;],[return X == 0;],
3994     [AC_MSG_RESULT([yes]); have_pic_shared=yes],
3995     [AC_MSG_RESULT([no]); have_pic_shared=no])
3996   if test x"$have_pic_shared" != x"yes"; then
3997     pluginlibs=
3998     enable_plugin=no
3999   fi
4000
4001   # If plugin support had been requested but not available, fail.
4002   if test x"$enable_plugin" = x"no" ; then
4003     if test x"$default_plugin" != x"yes"; then
4004       AC_MSG_ERROR([
4005 Building GCC with plugin support requires a host that supports
4006 -fPIC, -shared, -ldl and -rdynamic.])
4007     fi
4008   fi
4009
4010   LDFLAGS="$saved_LDFLAGS"
4011   LIBS="$saved_LIBS"
4012 fi
4013
4014 AC_SUBST(pluginlibs)
4015 AC_SUBST(enable_plugin)
4016 if test x"$enable_plugin" = x"yes"; then
4017   AC_DEFINE(ENABLE_PLUGIN, 1, [Define to enable plugin support.])
4018 fi
4019
4020 # Configure the subdirectories
4021 # AC_CONFIG_SUBDIRS($subdirs)
4022
4023 # Create the Makefile
4024 # and configure language subdirectories
4025 AC_CONFIG_FILES($all_outputs)
4026
4027 AC_CONFIG_COMMANDS([default],
4028 [
4029 case ${CONFIG_HEADERS} in
4030   *auto-host.h:config.in*)
4031   echo > cstamp-h ;;
4032 esac
4033 # Make sure all the subdirs exist.
4034 for d in $subdirs doc build
4035 do
4036     test -d $d || mkdir $d
4037 done
4038 ], 
4039 [subdirs='$subdirs'])
4040 AC_OUTPUT