OSDN Git Service

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