OSDN Git Service

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